• highSIMDVault cannot receive the launch's ETH fee share, so claimFees always fails and no creator fees are ever collectedsrc/SIMDVault.sol:169

  The intake-client reference says the launch factory's claimFees pays the requester its LP fee share 'in ETH and in tokens', and the launch body is a custom_token launch priced in wei (initialMarketCapWei), i.e. a native-ETH / TEST pool (currency0 = address(0)). SIMDVault has no receive() or fallback, so the factory's native transfer to the vault reverts, the whole claimFees reverts, and distribute() swallows it in try/catch (FeesClaimFailed) every week.

  Result: neither the ETH fees nor the TEST-side fees are ever collected (so nothing is ever burned), and the fees stay at the factory forever because the vault also has no setRequester path. Even with a receive() added, the brief's split only moves IMD and nothing lets ETH leave the vault, so ETH would be stranded instead; the fix needs both a way to accept ETH and a defined way to distribute it (or convert it to IMD).

  The existing mocks register an IMD/TEST pool, which is why the current suite does not catch this. I could not verify the live pool pairing from this machine (no reachable Robinhood Chain RPC); a fork run of factory.positionOf on a live custom_token launch is still owed.

  whole finding

  Factory stand-in with PoolKey(currency0=address(0), currency1=TEST) whose claimFees sends ETH with call and requires success (as Uniswap v4 CurrencyLibrary.transfer does). launch, bindLaunch, accrue 1 ETH + 1000 TEST, distribute().

  Expected: factory fees go to 0 and 1000 TEST reach 0x...dEaD.

  Actual: distribute emits FeesClaimFailed(NativeTransferFailed); factory still holds 1 ETH and 1000 TEST; burn address receives 0.

  proof · a Foundry test the fix has to pass

  // SPDX-License-Identifier: MIT
  pragma solidity 0.8.26;
  
  import {Test} from "forge-std/Test.sol";
  import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
  import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
  import {SIMDVault} from "src/SIMDVault.sol";
  import {IIntake} from "src/interfaces/IIntake.sol";
  import {ILaunchFactory} from "src/interfaces/ILaunchFactory.sol";
  
  contract Tok is ERC20 {
      constructor(string memory n) ERC20(n, n) {}
  
      function mint(address to, uint256 a) external {
          _mint(to, a);
      }
  }
  
  /// @dev Intake stand-in: pulls the price and forwards it, as the live one does.
  contract Intake {
      uint256 public nonce;
  
      function priceOf(bytes32, address) external pure returns (uint256) {
          return 0.5 ether;
      }
  
      function request(bytes32, bytes calldata, IIntake.Callback calldata, address asset, uint256 amount)
          external
          payable
          returns (bytes32)
      {
          IERC20(asset).transferFrom(msg.sender, address(0xBEEF), amount);
          return keccak256(abi.encode(++nonce));
      }
  }
  
  /// @dev Launch factory stand-in for a `custom_token` launch: the pool is native ETH / token
  /// (currency0 = address(0)), and `claimFees` pays the requester in ETH and in tokens, reverting
  /// when the native transfer fails, as Uniswap v4's `CurrencyLibrary.transfer` does.
  contract EthFactory {
      address public requester;
      address public tok;
      uint256 public feesEth;
      uint256 public feesTok;
  
      constructor(address requester_, address tok_) {
          requester = requester_;
          tok = tok_;
      }
  
      function accrue(uint256 tokAmount) external payable {
          feesEth += msg.value;
          feesTok += tokAmount;
      }
  
      function claimFees(uint64) external {
          (uint256 e, uint256 t) = (feesEth, feesTok);
          (feesEth, feesTok) = (0, 0);
          (bool ok,) = requester.call{value: e}("");
          require(ok, "NativeTransferFailed");
          IERC20(tok).transfer(requester, t);
      }
  
      function positionOf(uint64)
          external
          view
          returns (ILaunchFactory.PoolKey memory key, int24, int24, address)
      {
          key = ILaunchFactory.PoolKey(address(0), tok, 10_000, 200, address(0));
          return (key, -887200, 887200, requester);
      }
  }
  
  contract EthFeesProof is Test {
      function test_theVaultCanCollectTheLaunchsEthAndTokenFees() public {
          vm.roll(1000);
          Tok imd = new Tok("IMD");
          Tok token = new Tok("TEST");
          Intake intake = new Intake();
          address dev = makeAddr("dev");
          address predicted = vm.computeCreateAddress(address(this), vm.getNonce(address(this)) + 1);
          EthFactory factory = new EthFactory(predicted, address(token));
          SIMDVault vault = new SIMDVault(
              IERC20(address(imd)),
              IIntake(address(intake)),
              ILaunchFactory(address(factory)),
              dev,
              makeAddr("marketing"),
              makeAddr("signer"),
              false
          );
          assertEq(address(vault), predicted);
          imd.mint(address(vault), 10 ether);
          vm.startPrank(dev);
          vault.launch("{}");
          vault.bindLaunch(1, IERC20(address(token)));
          vm.stopPrank();
  
          token.mint(address(factory), 1000 ether);
          factory.accrue{value: 1 ether}(1000 ether);
          vault.distribute();
  
          // The creator fees the vault was built to own must actually be collected.
          assertEq(factory.feesEth(), 0, "ETH fee share never leaves the factory");
          assertEq(address(factory).balance, 0, "ETH fee share never leaves the factory");
          assertEq(token.balanceOf(vault.BURN()), 1000 ether, "token fee share never burned");
      }
  }

  whole proof

• mediumHolderRewards.claim does not cap an epoch's payouts at its pool; one inconsistent root drains earlier epochs and permanently bricks deposit/distributesrc/HolderRewards.sol:427

  claim pays e.pool * balance / total where total comes from the leaf, and never checks e.claimed + amount <= e.pool. If a delivered root's leaves carry a total smaller than the sum of their balances (an oracle mistake, or different totals in different leaves), the epoch pays out more than its pool, taken from IMD reserved for other epochs.

  When the earlier epoch's claim window closes, _rollClosed computes reserved -= unclaimed, which underflows, so every later deposit reverts; deposit is called from SIMDVault.distribute, so distribute reverts forever and all IMD in the vault is frozen (distribute is its only exit). One bad answer turns into permanent loss of liveness for the whole system rather than a loss bounded to one epoch.

  Two deposits of 10 IMD (pools 9.5 each).

  Epoch 2 answered with leaves (alice,1,1) and (bob,1,1). alice and bob each claim 9.5 IMD: epoch 2 claimed = 19 > pool 9.5, epoch 1 holders now unfunded.

  Warp 28 days and deposit again: expected success; actual panic 0x11 (arithmetic underflow) in _rollClosed, on every future call.

  proof · a Foundry test the fix has to pass

  // SPDX-License-Identifier: MIT
  pragma solidity 0.8.26;
  
  import {Test} from "forge-std/Test.sol";
  import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
  import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
  import {HolderRewards} from "src/HolderRewards.sol";
  import {IIntake} from "src/interfaces/IIntake.sol";
  import {OracleAttestation} from "src/oracle/OracleAttestation.sol";
  
  contract Tok is ERC20 {
      constructor(string memory n) ERC20(n, n) {}
  
      function mint(address to, uint256 a) external {
          _mint(to, a);
      }
  }
  
  contract Intake {
      uint256 public nonce;
  
      function priceOf(bytes32, address) external pure returns (uint256) {
          return 0.5 ether;
      }
  
      function request(bytes32, bytes calldata, IIntake.Callback calldata, address asset, uint256 amount)
          external
          payable
          returns (bytes32)
      {
          IERC20(asset).transferFrom(msg.sender, address(0xBEEF), amount);
          return keccak256(abi.encode(++nonce));
      }
  }
  
  /// @notice One answered root whose leaves carry a `total` smaller than the sum of their balances
  /// lets an epoch pay out more than its pool, out of earlier epochs' reserve. When the earlier
  /// epoch then closes, `_rollClosed` underflows on `reserved -= unclaimed` and every later
  /// `deposit` (so every `SIMDVault.distribute`) reverts forever.
  contract OverclaimProof is Test {
      uint256 internal constant KEY = 0xA11CE;
      Tok imd;
      Tok token;
      Intake intake;
      HolderRewards rewards;
      address alice = makeAddr("alice");
      address bob = makeAddr("bob");
  
      function setUp() public {
          vm.warp(1_800_000_000);
          vm.roll(1000);
          imd = new Tok("IMD");
          token = new Tok("TEST");
          intake = new Intake();
          rewards = new HolderRewards(
              address(this), IERC20(address(imd)), IIntake(address(intake)), makeAddr("factory"), makeAddr("jobs"),
              vm.addr(KEY), false
          );
          rewards.setToken(IERC20(address(token)));
          imd.mint(address(this), 100 ether);
          imd.approve(address(rewards), type(uint256).max);
      }
  
      function _answer(uint256 epoch, bytes32 root) internal {
          HolderRewards.Epoch memory e = rewards.epochs(epoch);
          OracleAttestation.Attestation memory a = OracleAttestation.Attestation({
              requestId: keccak256(abi.encode("att", epoch)),
              chainId: block.chainid,
              questionHash: e.questionHash,
              answerType: OracleAttestation.ANSWER_BYTES32,
              answer: abi.encode(root),
              figure: 0,
              fromBlock: e.snapshotBlock,
              toBlock: e.snapshotBlock,
              blockHash: bytes32(uint256(1)),
              panelJobId: bytes32(uint256(2)),
              panelSize: 5,
              quorum: 4,
              agreed: 5,
              issuedAt: uint64(block.timestamp),
              expiresAt: uint64(block.timestamp + 1 hours)
          });
          (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, rewards.attestationDigest(a));
          bytes32 requestId = keccak256(abi.encode(intake.nonce()));
          vm.prank(address(intake));
          rewards.onOracleResult(requestId, a, abi.encodePacked(r, s, v));
      }
  
      function test_oneOverpayingRootCannotBrickLaterEpochs() public {
          rewards.deposit(10 ether); // epoch 1, pool 9.5
          vm.warp(block.timestamp + 7 days);
          rewards.deposit(10 ether); // epoch 2, pool 9.5
  
          // Epoch 2's answered leaves: alice (1 of 1) and bob (1 of 1).
          bytes32 lA = rewards.leaf(alice, 1, 1);
          bytes32 lB = rewards.leaf(bob, 1, 1);
          bytes32 root = lA < lB ? keccak256(abi.encodePacked(lA, lB)) : keccak256(abi.encodePacked(lB, lA));
          _answer(2, root);
          bytes32[] memory pA = new bytes32[](1);
          pA[0] = lB;
          bytes32[] memory pB = new bytes32[](1);
          pB[0] = lA;
          vm.prank(alice);
          rewards.claim(2, 1, 1, pA);
          vm.prank(bob);
          try rewards.claim(2, 1, 1, pB) {} catch {}
  
          // No epoch may pay more than its pool.
          HolderRewards.Epoch memory e2 = rewards.epochs(2);
          assertLe(e2.claimed, e2.pool, "epoch 2 paid more than its pool");
  
          // And the week must keep running once epoch 1 closes.
          vm.warp(block.timestamp + 28 days);
          rewards.deposit(10 ether);
          assertGe(imd.balanceOf(address(rewards)), rewards.reserved());
      }
  }

  whole proof

• mediumJobsVault's 1,000,000-token gate and 24-hour limit are per address and read the live balance, so one holder (or a flash borrower) can open unlimited jobs per daysrc/JobsVault.sol:641

  requestJob checks token.balanceOf(msg.sender) at call time and a per-address cooldown. The same 1,000,000 tokens can be moved to a fresh address after each call (or borrowed from the pool / Uniswap v4 flash accounting inside one transaction by a throwaway contract), so the daily limit does not limit anyone and the JobsVault's whole weekly IMD can be spent by one actor in one block.

  The brief's wording ('any wallet holding ... at most once per 24 hours') is met literally, so this is reported as a design weakness for the requester rather than asserted as correct or wrong in the suite; a holding snapshot (e.g. HolderRewards' epoch root) or a minimum holding period would close it.

  Holder A with exactly 1,000,000 TEST calls requestJob, transfers the tokens to fresh address B, B calls requestJob, B transfers to C, ... in the same block.

  Expected under the brief's intent: one job per holder per 24h.

  Actual: one job per transfer, each paid 0.5 IMD by JobsVault, until JobsVault is empty.

• lowbindLaunch accepts IMD itself (or any pool currency) as the launched tokensrc/SIMDVault.sol:142

  bindLaunch only checks that token_ is one of the pool's two currencies. If the launch pool were IMD-paired, the dev wallet could bind IMD as the 'launched token' once and for good: distribute would then send the IMD dust to the burn address, JobsVault would gate on holding 1,000,000 IMD and HolderRewards would snapshot IMD holders. It is a one-shot dev-wallet mistake with no recovery, so a check token_ != imd (and != address(0) native) would be cheap.

  With the existing MockLaunchFactory (IMD/TEST pool) call bindLaunch(7, IMD) from the dev wallet: expected revert, actual success and jobsVault.token() == IMD.

Failed in the task.