Farseen0/scar-pairs huggingface dataset:
MEDIUM severity: Vulnerable function: ```\n    function _decreaseCurrentMinted(address account, uint256 amount) internal virtual {\n      . ```\n    function _decreaseCurrentMinted(address account, uint256 amount) internal virtual {\n        // If the burner is a vault, subtract burnt TAU from its currentMinted.\n        // This has a few highly unimportant edge cases which can generally be rectified by increasing the relevant vault's m

Vulnerable code:
```\n    function _decreaseCurrentMinted(address account, uint256 amount) internal virtual {\n        // If the burner is a vault, subtract burnt TAU from its currentMinted.\n        // This has a few highly unimportant edge cases which can generally be rectified by increasing the relevant vault's mintLimit.\n        uint256 accountMinted = currentMinted[account];\n        if (accountMinted >= amount) {\n            currentMinted[msg.sender] = accountMinted - amount;\n        }\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\n/\*\*\n\* @dev Create a new MiniMe token and save it for the user\n\* @param \_name String with. ```\n/\*\*\n\* @dev Create a new MiniMe token and save it for the user\n\* @param \_name String with the name for the token used by share holders in the organization\n\* @param \_symbol String with the symbol for the token used by share holders in the organization\n\*/\nfunction newToken(string memo

Vulnerable code:
```\n/\*\*\n\* @dev Create a new MiniMe token and save it for the user\n\* @param \_name String with the name for the token used by share holders in the organization\n\* @param \_symbol String with the symbol for the token used by share holders in the organization\n\*/\nfunction newToken(string memory \_name, string memory \_symbol) public returns (MiniMeToken) {\n    MiniMeToken token = \_createToken(\_name, \_symbol, TOKEN\_DECIMALS);\n    \_saveToken(token);\n    return token;\n}\n```\n
MEDIUM severity: Vulnerable function: ```\nRocketDAONodeTrustedInterface rocketDAONodeTrusted = RocketDAONodeTrustedIn. ```\nRocketDAONodeTrustedInterface rocketDAONodeTrusted = RocketDAONodeTrustedInterface(getContractAddress("rocketDAONodeTrusted"));\nif (calcBase.mul(submissionCount).div(rocketDAONodeTrusted.getMemberCount()) >= rocketDAOProtocolSettingsNetwork.getNodeConsensusThreshold()) {\n    // Update the pri

Vulnerable code:
```\nRocketDAONodeTrustedInterface rocketDAONodeTrusted = RocketDAONodeTrustedInterface(getContractAddress("rocketDAONodeTrusted"));\nif (calcBase.mul(submissionCount).div(rocketDAONodeTrusted.getMemberCount()) >= rocketDAOProtocolSettingsNetwork.getNodeConsensusThreshold()) {\n    // Update the price\n    updatePrices(\_block, \_rplPrice);\n}\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction buyCollateralFromAuction(address token, uint amount) override external {\n    Auction . ```\nfunction buyCollateralFromAuction(address token, uint amount) override external {\n    Auction memory auction = auctions[token];\n    // validate auction\n    require(_isAuctionOngoing(auction.startedAt, auction.expiryTime), "IF.no_ongoing_auction");\n\n    // transfer funds\n    uint vusdToTra

Vulnerable code:
```\nfunction buyCollateralFromAuction(address token, uint amount) override external {\n    Auction memory auction = auctions[token];\n    // validate auction\n    require(_isAuctionOngoing(auction.startedAt, auction.expiryTime), "IF.no_ongoing_auction");\n\n    // transfer funds\n    uint vusdToTransfer = _calcVusdAmountForAuction(auction, token, amount);\n    address buyer = _msgSender();\n    vusd.safeTransferFrom(buyer, address(this), vusdToTransfer);\n    IERC20(token).safeTransfer(buyer, amount); // will revert if there wasn't enough amount as requested\n\n    // close auction if no collateral left\n    if (IERC20(token).balanceOf(address(this)) == 0) { <- @audit-issue only cancels auction if balance = 0\n        auctions[token].startedAt = 0;\n    }\n}\n```\n
HIGH severity: Vulnerable function: ```\n        (s.share, left) = _claim(s);\n        require(left > 0, "TokenSale:. ```\n        (s.share, left) = _claim(s);\n        require(left > 0, "TokenSale: Nothing to claim");\n        uint256 refundTaxAmount;\n        if (s.taxAmount > 0) {\n            uint256 tax = userTaxRate(s.amount, msg.sender);\n            uint256 taxFreeAllc = _maxTaxfreeAllocation(msg.sender) * 

Vulnerable code:
```\n        (s.share, left) = _claim(s);\n        require(left > 0, "TokenSale: Nothing to claim");\n        uint256 refundTaxAmount;\n        if (s.taxAmount > 0) {\n            uint256 tax = userTaxRate(s.amount, msg.sender);\n            uint256 taxFreeAllc = _maxTaxfreeAllocation(msg.sender) * PCT_BASE;\n            if (taxFreeAllc >= s.share) {\n                refundTaxAmount = s.taxAmount;\n            } else {\n                refundTaxAmount = (left * tax) / POINT_BASE;\n            }\n            usdc.safeTransferFrom(marketingWallet, msg.sender, refundTaxAmount);\n        }\n```\n
MEDIUM severity: Vulnerable function: ```\nuint256 proofNb = (\_operatorData.length - 84) / 32;\nbytes32[] memory proo. ```\nuint256 proofNb = (\_operatorData.length - 84) / 32;\nbytes32[] memory proof = new bytes32[](proofNb);\nuint256 index = 0;\nfor (uint256 i = 116; i <= \_operatorData.length; i = i + 32) {\n    bytes32 temp;\n    assembly {\n        temp := mload(add(\_operatorData, i))\n    }\n    proof[index] 

Vulnerable code:
```\nuint256 proofNb = (\_operatorData.length - 84) / 32;\nbytes32[] memory proof = new bytes32[](proofNb);\nuint256 index = 0;\nfor (uint256 i = 116; i <= \_operatorData.length; i = i + 32) {\n    bytes32 temp;\n    assembly {\n        temp := mload(add(\_operatorData, i))\n    }\n    proof[index] = temp;\n    index++;\n}\n```\n
HIGH severity: Vulnerable function: ```\nfunction getPrice(address pair) external view returns (uint) {\n    (uint r0, uint r1,) = IUnis. ```\nfunction getPrice(address pair) external view returns (uint) {\n    (uint r0, uint r1,) = IUniswapV2Pair(pair).getReserves();\n\n    // 2 * sqrt(r0 * r1 * p0 * p1) / totalSupply\n    return FixedPointMathLib.sqrt(\n        r0\n        .mulWadDown(r1)\n        .mulWadDown(oracle.getPrice(IUniswa

Vulnerable code:
```\nfunction getPrice(address pair) external view returns (uint) {\n    (uint r0, uint r1,) = IUniswapV2Pair(pair).getReserves();\n\n    // 2 * sqrt(r0 * r1 * p0 * p1) / totalSupply\n    return FixedPointMathLib.sqrt(\n        r0\n        .mulWadDown(r1)\n        .mulWadDown(oracle.getPrice(IUniswapV2Pair(pair).token0()))\n        .mulWadDown(oracle.getPrice(IUniswapV2Pair(pair).token1()))\n    )\n    .mulDivDown(2e27, IUniswapV2Pair(pair).totalSupply());\n}\n```\n
MEDIUM severity: Vulnerable function: ```\n    require(\_validityStatus, "CollateralizationOracleWrapper: Collateraliz. ```\n    require(\_validityStatus, "CollateralizationOracleWrapper: CollateralizationOracle is invalid");\n\n    // set cache variables\n    cachedProtocolControlledValue = \_protocolControlledValue;\n    cachedUserCirculatingFei = \_userCirculatingFei;\n    cachedProtocolEquity = \_protocolEquity;\

Vulnerable code:
```\n    require(\_validityStatus, "CollateralizationOracleWrapper: CollateralizationOracle is invalid");\n\n    // set cache variables\n    cachedProtocolControlledValue = \_protocolControlledValue;\n    cachedUserCirculatingFei = \_userCirculatingFei;\n    cachedProtocolEquity = \_protocolEquity;\n\n    // reset time\n    \_initTimed();\n\n    // emit event\n    emit CachedValueUpdate(\n        msg.sender,\n        cachedProtocolControlledValue,\n        cachedUserCirculatingFei,\n        cachedProtocolEquity\n    );\n\n    return outdated\n        || \_isExceededDeviationThreshold(cachedProtocolControlledValue, \_protocolControlledValue)\n        || \_isExceededDeviationThreshold(cachedUserCirculatingFei, \_userCirculatingFei);\n}\n```\n
MEDIUM severity: Vulnerable function: ```\n  function validateWithdraw(\n    address reserveAddress,\n    uint256 amount,\n    uint256 use. ```\n  function validateWithdraw(\n    address reserveAddress,\n    uint256 amount,\n    uint256 userBalance,\n    mapping(address => DataTypes.ReserveData) storage reservesData,\n    DataTypes.UserConfigurationMap storage userConfig,\n    mapping(uint256 => address) storage reserves,\n    uint256 r

Vulnerable code:
```\n  function validateWithdraw(\n    address reserveAddress,\n    uint256 amount,\n    uint256 userBalance,\n    mapping(address => DataTypes.ReserveData) storage reservesData,\n    DataTypes.UserConfigurationMap storage userConfig,\n    mapping(uint256 => address) storage reserves,\n    uint256 reservesCount,\n    address oracle\n  ) external view {\n    require(amount != 0, Errors.VL_INVALID_AMOUNT);\n```\n
MEDIUM severity: Vulnerable function: ```\n    function _verifyRemoveSig(address fidOwner, bytes memory key, uint256 deadline, bytes memor. ```\n    function _verifyRemoveSig(address fidOwner, bytes memory key, uint256 deadline, bytes memory sig) internal {\n        _verifySig(\n            _hashTypedDataV4(\n                keccak256(abi.encode(REMOVE_TYPEHASH, fidOwner, keccak256(key), _useNonce(fidOwner), deadline))\n            ),\n

Vulnerable code:
```\n    function _verifyRemoveSig(address fidOwner, bytes memory key, uint256 deadline, bytes memory sig) internal {\n        _verifySig(\n            _hashTypedDataV4(\n                keccak256(abi.encode(REMOVE_TYPEHASH, fidOwner, keccak256(key), _useNonce(fidOwner), deadline))\n            ),\n            fidOwner,\n            deadline,\n            sig\n        );\n    }\n```\n
HIGH severity: Vulnerable function: ```\nfunction requestLinkTopHatToTree(uint32 _topHatDomain, uint256 _requestedAdminHat) external {\n. ```\nfunction requestLinkTopHatToTree(uint32 _topHatDomain, uint256 _requestedAdminHat) external {\n    uint256 fullTopHatId = uint256(_topHatDomain) << 224; // (256 - TOPHAT_ADDRESS_SPACE);\n\n    _checkAdmin(fullTopHatId);\n\n    linkedTreeRequests[_topHatDomain] = _requestedAdminHat;\n    emit To

Vulnerable code:
```\nfunction requestLinkTopHatToTree(uint32 _topHatDomain, uint256 _requestedAdminHat) external {\n    uint256 fullTopHatId = uint256(_topHatDomain) << 224; // (256 - TOPHAT_ADDRESS_SPACE);\n\n    _checkAdmin(fullTopHatId);\n\n    linkedTreeRequests[_topHatDomain] = _requestedAdminHat;\n    emit TopHatLinkRequested(_topHatDomain, _requestedAdminHat);\n}\n```\n
MEDIUM severity: Vulnerable function: ```\n   function execute(\n        mapping(uint256 => IGovPool.Proposal) storage proposals,\n       . ```\n   function execute(\n        mapping(uint256 => IGovPool.Proposal) storage proposals,\n        uint256 proposalId\n    ) external {\n        // rest of code. // code\n\n        for (uint256 i; i < actionsLength; i++) {\n>            (bool status, bytes memory returnedData) = actions[i].executo

Vulnerable code:
```\n   function execute(\n        mapping(uint256 => IGovPool.Proposal) storage proposals,\n        uint256 proposalId\n    ) external {\n        // rest of code. // code\n\n        for (uint256 i; i < actionsLength; i++) {\n>            (bool status, bytes memory returnedData) = actions[i].executor.call{\n                value: actions[i].value\n            }(actions[i].data); //@audit returnedData could expand memory and cause out-of-gas exception\n\n            require(status, returnedData.getRevertMsg());\n        }\n   }\n```\n
MEDIUM severity: Vulnerable function: ```\n   function _setTemplate(\n        string memory templateName,\n        uint256 templateVersion. ```\n   function _setTemplate(\n        string memory templateName,\n        uint256 templateVersion,\n        address implementationAddress\n    ) internal {\n// rest of code\n\n        if (latestImplementation[templateName] == address(0)) { /****add other version, _templateNames will duplicate ***

Vulnerable code:
```\n   function _setTemplate(\n        string memory templateName,\n        uint256 templateVersion,\n        address implementationAddress\n    ) internal {\n// rest of code\n\n        if (latestImplementation[templateName] == address(0)) { /****add other version, _templateNames will duplicate ****/\n            _templateNames.push(templateName);\n        }\n\n        if (templateVersion > latestVersion[templateName]) {\n            latestVersion[templateName] = templateVersion;\n            latestImplementation[templateName] = implementationAddress; /****templateVersion==0 ,  don't set ****/\n        }\n\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\n\_poolById[poolId].numberOfMakers = uint256(\_poolById[poolId].numberOfMake. ```\n\_poolById[poolId].numberOfMakers = uint256(\_poolById[poolId].numberOfMakers).safeSub(1).downcastToUint32();\n```\n

Vulnerable code:
```\n\_poolById[poolId].numberOfMakers = uint256(\_poolById[poolId].numberOfMakers).safeSub(1).downcastToUint32();\n```\n
HIGH severity: Vulnerable function: ```\n        uint locked = \_getAndUpdateLockedAmount(from);\n        if (locked. ```\n        uint locked = \_getAndUpdateLockedAmount(from);\n        if (locked > 0) {\n            require(\_balances[from] >= locked.add(amount), "Token should be unlocked for burning");\n        }\n//-------------------------------------------------------------------------\n\n        \_callToken

Vulnerable code:
```\n        uint locked = \_getAndUpdateLockedAmount(from);\n        if (locked > 0) {\n            require(\_balances[from] >= locked.add(amount), "Token should be unlocked for burning");\n        }\n//-------------------------------------------------------------------------\n\n        \_callTokensToSend(\n            operator, from, address(0), amount, data, operatorData\n        );\n\n        // Update state variables\n        \_totalSupply = \_totalSupply.sub(amount);\n        \_balances[from] = \_balances[from].sub(amount);\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction \_swapLidoForWETH(uint256 amountToSwap) internal {\n    IUniswapSwapRouter.ExactInputS. ```\nfunction \_swapLidoForWETH(uint256 amountToSwap) internal {\n    IUniswapSwapRouter.ExactInputSingleParams\n        memory params = IUniswapSwapRouter.ExactInputSingleParams({\n            tokenIn: address(ldo),\n            tokenOut: address(weth),\n            fee: UNISWAP\_FEE,\n            

Vulnerable code:
```\nfunction \_swapLidoForWETH(uint256 amountToSwap) internal {\n    IUniswapSwapRouter.ExactInputSingleParams\n        memory params = IUniswapSwapRouter.ExactInputSingleParams({\n            tokenIn: address(ldo),\n            tokenOut: address(weth),\n            fee: UNISWAP\_FEE,\n            recipient: address(this),\n            deadline: block.timestamp,\n            amountIn: amountToSwap,\n            amountOutMinimum: 0,\n            sqrtPriceLimitX96: 0\n        });\n    uniswapRouter.exactInputSingle(params);\n}\n```\n
HIGH severity: Vulnerable function: ```\ndaiAToken balance = 30000\nwethDebtToken balance = 10\n\nThe price of WETH . ```\ndaiAToken balance = 30000\nwethDebtToken balance = 10\n\nThe price of WETH when the trade was opened was ~ 3000 DAI\n```\n

Vulnerable code:
```\ndaiAToken balance = 30000\nwethDebtToken balance = 10\n\nThe price of WETH when the trade was opened was ~ 3000 DAI\n```\n
MEDIUM severity: Vulnerable function: ```\nFile: ERC4626Oracle.sol\n    function getPrice(address token) external view returns (uint) {\n . ```\nFile: ERC4626Oracle.sol\n    function getPrice(address token) external view returns (uint) {\n        uint decimals = IERC4626(token).decimals();\n        return IERC4626(token).previewRedeem(\n            10 ** decimals\n        ).mulDivDown(\n            oracleFacade.getPrice(IERC4626(token).

Vulnerable code:
```\nFile: ERC4626Oracle.sol\n    function getPrice(address token) external view returns (uint) {\n        uint decimals = IERC4626(token).decimals();\n        return IERC4626(token).previewRedeem(\n            10 ** decimals\n        ).mulDivDown(\n            oracleFacade.getPrice(IERC4626(token).asset()),\n            10 ** decimals\n        );\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\nIs the admin/owner of the protocol/contracts TRUSTED or RESTRICTED?\n\nRest. ```\nIs the admin/owner of the protocol/contracts TRUSTED or RESTRICTED?\n\nRestricted. The governor address should not be able to steal funds or prevent users from withdrawing. It does have access to the govern methods in Factory, and it could trigger liquidations by increasing nSigma. We consider 

Vulnerable code:
```\nIs the admin/owner of the protocol/contracts TRUSTED or RESTRICTED?\n\nRestricted. The governor address should not be able to steal funds or prevent users from withdrawing. It does have access to the govern methods in Factory, and it could trigger liquidations by increasing nSigma. We consider this an acceptable risk, and the governor itself will have a timelock.\n```\n
HIGH severity: Vulnerable function: ```\nfunction setOperatorStrategyCap(\n        RioLRTOperatorRegistryStorageV1.StorageV1 storage s,\. ```\nfunction setOperatorStrategyCap(\n        RioLRTOperatorRegistryStorageV1.StorageV1 storage s,\n        uint8 operatorId,\n        IRioLRTOperatorRegistry.StrategyShareCap memory newShareCap\n    ) internal {\n        .\n        OperatorUtilizationHeap.Data memory utilizationHeap = s.getOperato

Vulnerable code:
```\nfunction setOperatorStrategyCap(\n        RioLRTOperatorRegistryStorageV1.StorageV1 storage s,\n        uint8 operatorId,\n        IRioLRTOperatorRegistry.StrategyShareCap memory newShareCap\n    ) internal {\n        .\n        OperatorUtilizationHeap.Data memory utilizationHeap = s.getOperatorUtilizationHeapForStrategy(newShareCap.strategy);\n        // If the current cap is greater than 0 and the new cap is 0, remove the operator from the strategy.\n        if (currentShareDetails.cap > 0 && newShareCap.cap == 0) {\n            // If the operator has allocations, queue them for exit.\n            if (currentShareDetails.allocation > 0) {\n                operatorDetails.queueOperatorStrategyExit(operatorId, newShareCap.strategy);\n            }\n            // Remove the operator from the utilization heap.\n            -> utilizationHeap.removeByID(operatorId);\n        }\n        .\n\n        // Persist the updated heap to the active operators tracking.\n        -> utilizationHeap.store(s.activeOperatorsByStrategyShareUtilization[newShareCap.strategy]);\n         .\n    }\n```\n
HIGH severity: Vulnerable function: ```\nsetSettingUint('members.challenge.cooldown', 6172);              // How lon. ```\nsetSettingUint('members.challenge.cooldown', 6172);              // How long a member must wait before performing another challenge, approx. 1 day worth of blocks\nsetSettingUint('members.challenge.window', 43204);               // How long a member has to respond to a challenge. 7 days worth o

Vulnerable code:
```\nsetSettingUint('members.challenge.cooldown', 6172);              // How long a member must wait before performing another challenge, approx. 1 day worth of blocks\nsetSettingUint('members.challenge.window', 43204);               // How long a member has to respond to a challenge. 7 days worth of blocks\nsetSettingUint('members.challenge.cost', 1 ether);               // How much it costs a non-member to challenge a members node. It's free for current members to challenge other members.\n```\n
HIGH severity: Vulnerable function: ```\n    uint256 minPrice = base.getPrice(tokens[0]);\n    for(uint256 i = 1; i . ```\n    uint256 minPrice = base.getPrice(tokens[0]);\n    for(uint256 i = 1; i != length; ++i) {\n        uint256 price = base.getPrice(tokens[i]);\n        minPrice = (price < minPrice) ? price : minPrice;\n    }\n    return minPrice.mulWadDown(pool.getRate());\n```\n

Vulnerable code:
```\n    uint256 minPrice = base.getPrice(tokens[0]);\n    for(uint256 i = 1; i != length; ++i) {\n        uint256 price = base.getPrice(tokens[i]);\n        minPrice = (price < minPrice) ? price : minPrice;\n    }\n    return minPrice.mulWadDown(pool.getRate());\n```\n
MEDIUM severity: Vulnerable function: ```\n    function _routerSwap(\n        uint16 _dstChainId,\n        uint256 _srcPoolId,\n        ui. ```\n    function _routerSwap(\n        uint16 _dstChainId,\n        uint256 _srcPoolId,\n        uint256 _dstPoolId,\n        uint256 _amount,\n        uint256 _slippage,\n        address payable _oft,\n        address _erc20\n    ) private {\n        bytes memory _dst = abi.encodePacked(connectedO

Vulnerable code:
```\n    function _routerSwap(\n        uint16 _dstChainId,\n        uint256 _srcPoolId,\n        uint256 _dstPoolId,\n        uint256 _amount,\n        uint256 _slippage,\n        address payable _oft,\n        address _erc20\n    ) private {\n        bytes memory _dst = abi.encodePacked(connectedOFTs[_oft][_dstChainId].dstOft);\n      IERC20(_erc20).safeApprove(address(router), _amount);\n        router.swap{value: msg.value}(\n            _dstChainId,\n            _srcPoolId,\n            _dstPoolId,\n            payable(this),\n            _amount,\n            _computeMinAmount(_amount, _slippage),\n            IStargateRouterBase.lzTxObj({dstGasForCall: 0, dstNativeAmount: 0, dstNativeAddr: "0x0"}),\n            _dst,\n            "0x"\n        );\n    }\n```\n
HIGH severity: Vulnerable function: ```\nfunction withdrawInsurance(uint256 amount, address to)\n    external\n    nonReentrant\n    onl. ```\nfunction withdrawInsurance(uint256 amount, address to)\n    external\n    nonReentrant\n    onlyOwner\n{\n    if (amount == 0) {\n        revert ZeroAmount();\n    }\n\n    insuranceDeposited -= amount;\n\n    vault.withdraw(insuranceToken(), amount);\n    IERC20(insuranceToken()).transfer(to, 

Vulnerable code:
```\nfunction withdrawInsurance(uint256 amount, address to)\n    external\n    nonReentrant\n    onlyOwner\n{\n    if (amount == 0) {\n        revert ZeroAmount();\n    }\n\n    insuranceDeposited -= amount;\n\n    vault.withdraw(insuranceToken(), amount);\n    IERC20(insuranceToken()).transfer(to, amount);\n\n    emit InsuranceWithdrawn(msg.sender, to, amount);\n}\n```\n
HIGH severity: Vulnerable function: ```\n  function fund(IMarket market) external {\n        if (!instances(IInstance(address(market)))). ```\n  function fund(IMarket market) external {\n        if (!instances(IInstance(address(market)))) revert FactoryNotInstanceError();\n      market.claimFee();\n    }\n```\n

Vulnerable code:
```\n  function fund(IMarket market) external {\n        if (!instances(IInstance(address(market)))) revert FactoryNotInstanceError();\n      market.claimFee();\n    }\n```\n
HIGH severity: Vulnerable function: ```\nfunction dismissSlashProposal(uint256 \_proposalId, string[] calldata \_evidence) external only. ```\nfunction dismissSlashProposal(uint256 \_proposalId, string[] calldata \_evidence) external onlyRole(SLASHING\_ARBITER\_ROLE) {\n    \_transition(\_proposalId, DISMISSED);\n    \_submitEvidence(\_proposalId, DISMISSED, \_evidence);\n    \_returnDeposit(\_proposalId);\n    \_unfreeze(\_proposalId

Vulnerable code:
```\nfunction dismissSlashProposal(uint256 \_proposalId, string[] calldata \_evidence) external onlyRole(SLASHING\_ARBITER\_ROLE) {\n    \_transition(\_proposalId, DISMISSED);\n    \_submitEvidence(\_proposalId, DISMISSED, \_evidence);\n    \_returnDeposit(\_proposalId);\n    \_unfreeze(\_proposalId);\n}\n```\n
HIGH severity: Vulnerable function: ```\nFile: ERC20.sol\n    function _mint(address account, uint256 amount) internal virtual {\n..SNIP. ```\nFile: ERC20.sol\n    function _mint(address account, uint256 amount) internal virtual {\n..SNIP..\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply += amount;\n        unchecked {\n            // Overflow not possible: balance + amount is at most totalSupply + 

Vulnerable code:
```\nFile: ERC20.sol\n    function _mint(address account, uint256 amount) internal virtual {\n..SNIP..\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply += amount;\n        unchecked {\n            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\n            _balances[account] += amount;\n        }\n..SNIP..\n        _afterTokenTransfer(address(0), account, amount);\n    }\n```\n