Farseen0/scar-pairs huggingface dataset:
HIGH severity: Vulnerable function: ```\n            function increaseLiquidity(IncreaseLiquidityParams calldata params)\n              . ```\n            function increaseLiquidity(IncreaseLiquidityParams calldata params)\n                 external payable override checkDeadline(params.deadline)\n                    returns (\n                     uint128 liquidity, uint256 amount0, uint256 amount1)\n            {\n            Positi

Vulnerable code:
```\n            function increaseLiquidity(IncreaseLiquidityParams calldata params)\n                 external payable override checkDeadline(params.deadline)\n                    returns (\n                     uint128 liquidity, uint256 amount0, uint256 amount1)\n            {\n            Position storage position = _positions[params.tokenId];\n                PoolAddress.PoolKey memory poolKey = _poolIdToPoolKey[position.poolId];\n                    IUniswapV3Pool pool;\n                        (liquidity, amount0, amount1, pool) = addLiquidity(\n```\n
MEDIUM severity: Vulnerable function: ```\nassembly ("memory-safe") {\n // // rest of code\n liabilities0 := div(liabi. ```\nassembly ("memory-safe") {\n // // rest of code\n liabilities0 := div(liabilities0, strain) // @audit rounds down to 0 <-\n liabilities1 := div(liabilities1, strain) // @audit rounds down to 0 <-\n // // rest of code\n}\n```\n

Vulnerable code:
```\nassembly ("memory-safe") {\n // // rest of code\n liabilities0 := div(liabilities0, strain) // @audit rounds down to 0 <-\n liabilities1 := div(liabilities1, strain) // @audit rounds down to 0 <-\n // // rest of code\n}\n```\n
MEDIUM severity: Vulnerable function: ```\nRunning 1 test for test/scenario/BorrowAndRepay.scenario.t.sol:BorrowAndRep. ```\nRunning 1 test for test/scenario/BorrowAndRepay.scenario.t.sol:BorrowAndRepay_Scenario_Test\n[PASS] testScenario_Poc() (gas: 799155)\nLogs:\n  100 initial pool balance. This is also the amount deposited into tranche\n  warp 2 minutes into future\n  mint was used rather than deposit to ensure no

Vulnerable code:
```\nRunning 1 test for test/scenario/BorrowAndRepay.scenario.t.sol:BorrowAndRepay_Scenario_Test\n[PASS] testScenario_Poc() (gas: 799155)\nLogs:\n  100 initial pool balance. This is also the amount deposited into tranche\n  warp 2 minutes into future\n  mint was used rather than deposit to ensure no rounding error. This a UTILISATION manipulation attack not a share inflation attack\n  22 shares were burned in exchange for 100000 assets. Users.LiquidityProvider only deposited 100 asset in the tranche but withdrew 100000 assets!\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction plunder(\n  address erc721,\n  uint256 tokenId,\n  IERC20[] calldata erc20s,\n  LootBo. ```\nfunction plunder(\n  address erc721,\n  uint256 tokenId,\n  IERC20[] calldata erc20s,\n  LootBox.WithdrawERC721[] calldata erc721s,\n  LootBox.WithdrawERC1155[] calldata erc1155s\n) external {\n  address payable owner = payable(IERC721(erc721).ownerOf(tokenId));\n```\n

Vulnerable code:
```\nfunction plunder(\n  address erc721,\n  uint256 tokenId,\n  IERC20[] calldata erc20s,\n  LootBox.WithdrawERC721[] calldata erc721s,\n  LootBox.WithdrawERC1155[] calldata erc1155s\n) external {\n  address payable owner = payable(IERC721(erc721).ownerOf(tokenId));\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction getTellorCurrentValue(bytes32 _queryId)\n ..SNIP..\n    // retrieve most recent 20+ mi. ```\nfunction getTellorCurrentValue(bytes32 _queryId)\n ..SNIP..\n    // retrieve most recent 20+ minute old value for a queryId. the time buffer allows time for a bad value to be disputed\n    (, bytes memory data, uint256 timestamp) = tellor.getDataBefore(_queryId, block.timestamp - 20 minutes);\n

Vulnerable code:
```\nfunction getTellorCurrentValue(bytes32 _queryId)\n ..SNIP..\n    // retrieve most recent 20+ minute old value for a queryId. the time buffer allows time for a bad value to be disputed\n    (, bytes memory data, uint256 timestamp) = tellor.getDataBefore(_queryId, block.timestamp - 20 minutes);\n    uint256 _value = abi.decode(data, (uint256));\n    if (timestamp == 0 || _value == 0) return (false, _value, timestamp);\n```\n
HIGH severity: Vulnerable function: ```\nFile: wfCashLogic.sol\n    function _lendLegacy(\nFile: wfCashLogic.sol\n        // If deposit . ```\nFile: wfCashLogic.sol\n    function _lendLegacy(\nFile: wfCashLogic.sol\n        // If deposit amount external is in excess of the cost to purchase fCash amount (often the case),\n        // then we need to return the difference between postTradeCash - preTradeCash. This is done because\n      

Vulnerable code:
```\nFile: wfCashLogic.sol\n    function _lendLegacy(\nFile: wfCashLogic.sol\n        // If deposit amount external is in excess of the cost to purchase fCash amount (often the case),\n        // then we need to return the difference between postTradeCash - preTradeCash. This is done because\n        // the encoded trade does not automatically withdraw the entire cash balance in case the wrapper\n        // is holding a cash balance.\n        uint256 preTradeCash = getCashBalance();\n\n        BalanceActionWithTrades[] memory action = EncodeDecode.encodeLegacyLendTrade(\n            currencyId,\n            getMarketIndex(),\n            depositAmountExternal,\n            fCashAmount,\n            minImpliedRate\n        );\n        // Notional will return any residual ETH as the native token. When we _sendTokensToReceiver those\n        // native ETH tokens will be wrapped back to WETH.\n        NotionalV2.batchBalanceAndTradeAction{value: msgValue}(address(this), action); \n\n        uint256 postTradeCash = getCashBalance(); \n\n        if (preTradeCash != postTradeCash) { \n            // If ETH, then redeem to WETH (redeemToUnderlying == false)\n            NotionalV2.withdraw(currencyId, _safeUint88(postTradeCash - preTradeCash), !isETH);\n        }\n    }\n```\n
HIGH severity: Vulnerable function: ```\n/\*\*\n \* @dev Routing Function for Flashloan Provider\n \* @param info: struct information fo. ```\n/\*\*\n \* @dev Routing Function for Flashloan Provider\n \* @param info: struct information for flashLoan\n \* @param \_flashnum: integer identifier of flashloan provider\n \*/\nfunction initiateFlashloan(FlashLoan.Info calldata info, uint8 \_flashnum) external isAuthorized override {\n if (\_

Vulnerable code:
```\n/\*\*\n \* @dev Routing Function for Flashloan Provider\n \* @param info: struct information for flashLoan\n \* @param \_flashnum: integer identifier of flashloan provider\n \*/\nfunction initiateFlashloan(FlashLoan.Info calldata info, uint8 \_flashnum) external isAuthorized override {\n if (\_flashnum == 0) {\n \_initiateGeistFlashLoan(info);\n } else if (\_flashnum == 2) {\n \_initiateCreamFlashLoan(info);\n } else {\n revert(Errors.VL\_INVALID\_FLASH\_NUMBER);\n }\n}\n```\n
MEDIUM severity: Vulnerable function: ```\n    function getMarketTokenPrice(\n        DataStore dataStore,\n        Market.Props memory ma. ```\n    function getMarketTokenPrice(\n        DataStore dataStore,\n        Market.Props memory market,\n        Price.Props memory indexTokenPrice,\n        Price.Props memory longTokenPrice,\n        Price.Props memory shortTokenPrice,\n        bytes32 pnlFactorType,\n        bool maximize\n    

Vulnerable code:
```\n    function getMarketTokenPrice(\n        DataStore dataStore,\n        Market.Props memory market,\n        Price.Props memory indexTokenPrice,\n        Price.Props memory longTokenPrice,\n        Price.Props memory shortTokenPrice,\n        bytes32 pnlFactorType,\n        bool maximize\n    ) external view returns (int256, MarketPoolValueInfo.Props memory) {\n        return\n            MarketUtils.getMarketTokenPrice(\n                dataStore,\n                market,\n                indexTokenPrice,\n                longTokenPrice,\n                shortTokenPrice,\n                pnlFactorType,\n                maximize\n            );\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\n require(s.ss[token].milestoneSeason == 0, "Whitelist: Token already whitel. ```\n require(s.ss[token].milestoneSeason == 0, "Whitelist: Token already whitelisted");\n```\n

Vulnerable code:
```\n require(s.ss[token].milestoneSeason == 0, "Whitelist: Token already whitelisted");\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction _calculateQuoteAssetQuantity(bool isSellAuction, uint256 _componentQuantity, uint256 _. ```\nfunction _calculateQuoteAssetQuantity(bool isSellAuction, uint256 _componentQuantity, uint256 _componentPrice) private pure returns (uint256) {\n    return isSellAuction ? _componentQuantity.preciseMulCeil(_componentPrice) : _componentQuantity.preciseMul(_componentPrice);\n}\n```\n

Vulnerable code:
```\nfunction _calculateQuoteAssetQuantity(bool isSellAuction, uint256 _componentQuantity, uint256 _componentPrice) private pure returns (uint256) {\n    return isSellAuction ? _componentQuantity.preciseMulCeil(_componentPrice) : _componentQuantity.preciseMul(_componentPrice);\n}\n```\n
MEDIUM severity: Vulnerable function: ```\n        try priceFeedA.latestRoundData() returns (\n            uint80,\n  . ```\n        try priceFeedA.latestRoundData() returns (\n            uint80,\n            int256 price,\n            uint256,\n            uint256 updatedAt,\n            uint80\n        ) {\n            require(\n                block.timestamp - updatedAt <= outdated, // solhint-disable-line not-r

Vulnerable code:
```\n        try priceFeedA.latestRoundData() returns (\n            uint80,\n            int256 price,\n            uint256,\n            uint256 updatedAt,\n            uint80\n        ) {\n            require(\n                block.timestamp - updatedAt <= outdated, // solhint-disable-line not-rely-on-time\n                "ChainLinkOracle: priceFeedA outdated."\n            );\n\n            priceA = SafeCast.toUint256(price);\n        } catch {\n            revert("ChainLinkOracle: price feed A call failed.");\n        }\n\n        try priceFeedB.latestRoundData() returns (\n            uint80,\n            int256 price,\n            uint256,\n            uint256 updatedAt,\n            uint80\n        ) {\n            require(\n                block.timestamp - updatedAt <= outdated, // solhint-disable-line not-rely-on-time\n                "ChainLinkOracle: priceFeedB outdated."\n            );\n\n            priceB = SafeCast.toUint256(price);\n        } catch {\n            revert("ChainLinkOracle: price feed B call failed.");\n        }\n```\n
HIGH severity: Vulnerable function: ```\n                if (isCurrencyAllowed[tokenAddress] != 1) {\n              . ```\n                if (isCurrencyAllowed[tokenAddress] != 1) {\n                    revert InvalidCollection();\n                }\n```\n

Vulnerable code:
```\n                if (isCurrencyAllowed[tokenAddress] != 1) {\n                    revert InvalidCollection();\n                }\n```\n
MEDIUM severity: Vulnerable function: ```\nshares = totalSupply() > 0\n    ? (totalSupply() \* amountIn) / totalVaultF. ```\nshares = totalSupply() > 0\n    ? (totalSupply() \* amountIn) / totalVaultFunds()\n    : amountIn;\n```\n

Vulnerable code:
```\nshares = totalSupply() > 0\n    ? (totalSupply() \* amountIn) / totalVaultFunds()\n    : amountIn;\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction _validateSigner(\n    uint256 timestamp,\n    address asset,\n    uint256 price,\n    . ```\nfunction _validateSigner(\n    uint256 timestamp,\n    address asset,\n    uint256 price,\n    bytes memory signature\n) internal view returns (bool) {\n    bytes32 digest = ECDSA.toEthSignedMessageHash(\n        keccak256(abi.encodePacked(timestamp, asset, price))\n    );\n    address recovere

Vulnerable code:
```\nfunction _validateSigner(\n    uint256 timestamp,\n    address asset,\n    uint256 price,\n    bytes memory signature\n) internal view returns (bool) {\n    bytes32 digest = ECDSA.toEthSignedMessageHash(\n        keccak256(abi.encodePacked(timestamp, asset, price))\n    );\n    address recoveredSigner = ECDSA.recover(digest, signature);\n    return recoveredSigner == publisher;\n}\n```\n
MEDIUM severity: Vulnerable function: ```\nrequire(\_numberOfWinners > 0, "MultipleWinners/num-gt-zero");\n```\n. ```\nrequire(\_numberOfWinners > 0, "MultipleWinners/num-gt-zero");\n```\n

Vulnerable code:
```\nrequire(\_numberOfWinners > 0, "MultipleWinners/num-gt-zero");\n```\n
HIGH severity: Vulnerable function: ```\n    while (_quantity > 0) {\n        Receipt memory deposit = deposits[i];\. ```\n    while (_quantity > 0) {\n        Receipt memory deposit = deposits[i];\n        if (deposit.amount == 0) {\n            i++;\n            continue;\n        }\n        if (deposit.amount <= _quantity) {\n            // deposit amount is lesser than quantity use it fully\n            _quanti

Vulnerable code:
```\n    while (_quantity > 0) {\n        Receipt memory deposit = deposits[i];\n        if (deposit.amount == 0) {\n            i++;\n            continue;\n        }\n        if (deposit.amount <= _quantity) {\n            // deposit amount is lesser than quantity use it fully\n            _quantity = _quantity - deposit.amount;\n            usdBalance[deposit.sender] -= deposit.amount;\n            amountToSend = (deposit.amount * 1e18) / _price;\n            IERC20(crab).transfer(deposit.sender, amountToSend);\n            emit USDCDeposited(deposit.sender, deposit.amount, amountToSend, i, 0);\n            delete deposits[i];\n            i++;\n        } else {\n            // deposit amount is greater than quantity; use it partially\n            deposits[i].amount = deposit.amount - _quantity;\n            usdBalance[deposit.sender] -= _quantity;\n            amountToSend = (_quantity * 1e18) / _price;\n            IERC20(crab).transfer(deposit.sender, amountToSend);\n            emit USDCDeposited(deposit.sender, _quantity, amountToSend, i, 0);\n            _quantity = 0;\n        }\n    }\n```\n
HIGH severity: Vulnerable function: ```\nsettleFundingFees() = Short/LP need to pay Long 100\n\nmarginDepositedTotal. ```\nsettleFundingFees() = Short/LP need to pay Long 100\n\nmarginDepositedTotal = marginDepositedTotal + funding fee\nmarginDepositedTotal = y + (-100) = (y - 100)\n\nstableCollateralTotal = x + (-(-100)) = (x + 100)\n```\n

Vulnerable code:
```\nsettleFundingFees() = Short/LP need to pay Long 100\n\nmarginDepositedTotal = marginDepositedTotal + funding fee\nmarginDepositedTotal = y + (-100) = (y - 100)\n\nstableCollateralTotal = x + (-(-100)) = (x + 100)\n```\n
MEDIUM severity: Vulnerable function: ```\n/\*\*\n \* @notice This is used by any router to decrease their available\n \* liquidity for a . ```\n/\*\*\n \* @notice This is used by any router to decrease their available\n \* liquidity for a given asset.\n \* @param shares The amount of liquidity to remove for the router in shares\n \* @param assetId The address (or `address(0)` if native asset) of the\n \* asset you're removing liquidity

Vulnerable code:
```\n/\*\*\n \* @notice This is used by any router to decrease their available\n \* liquidity for a given asset.\n \* @param shares The amount of liquidity to remove for the router in shares\n \* @param assetId The address (or `address(0)` if native asset) of the\n \* asset you're removing liquidity for\n \* @param recipient The address that will receive the liquidity being removed\n \*/\nfunction removeLiquidity(\n  uint256 shares,\n  address assetId,\n  address payable recipient\n) external override {\n  // Sanity check: recipient is sensible\n  require(recipient != address(0), "#RL:007");\n\n  // Sanity check: nonzero shares\n  require(shares > 0, "#RL:035");\n\n  // Get stored router shares\n  uint256 routerShares = issuedShares[msg.sender][assetId];\n\n  // Get stored outstanding shares\n  uint256 outstanding = outstandingShares[assetId];\n\n  // Sanity check: owns enough shares\n  require(routerShares >= shares, "#RL:018");\n\n  // Convert shares to amount\n  uint256 amount = getAmountFromIssuedShares(\n    shares,\n    outstanding,\n    Asset.getOwnBalance(assetId)\n  );\n\n  // Update router issued shares\n  // NOTE: unchecked due to require above\n  unchecked {\n    issuedShares[msg.sender][assetId] = routerShares - shares;\n  }\n\n  // Update the total shares for asset\n  outstandingShares[assetId] = outstanding - shares;\n\n  // Transfer from contract to specified recipient\n  Asset.transferAsset(assetId, recipient, amount);\n\n  // Emit event\n  emit LiquidityRemoved(\n    msg.sender,\n    assetId,\n    shares,\n    amount,\n    recipient\n  );\n}\n```\n
HIGH severity: Vulnerable function: ```\nrequire(\n    gasleft() >= _tx.gasLimit + FINALIZE_GAS_BUFFER,\n    "Optimi. ```\nrequire(\n    gasleft() >= _tx.gasLimit + FINALIZE_GAS_BUFFER,\n    "OptimismPortal: insufficient gas to finalize withdrawal"\n);\n```\n

Vulnerable code:
```\nrequire(\n    gasleft() >= _tx.gasLimit + FINALIZE_GAS_BUFFER,\n    "OptimismPortal: insufficient gas to finalize withdrawal"\n);\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction testVaultFeeIncorrectlySet() public {\n  Dummy721 nft = new Dummy721();\n  address tok. ```\nfunction testVaultFeeIncorrectlySet() public {\n  Dummy721 nft = new Dummy721();\n  address tokenContract = address(nft);\n  uint256 tokenId = uint256(1);\n  address publicVault = _createPublicVault({\n      strategist: strategistOne,\n      delegate: strategistTwo,\n      epochLength: 14 days\

Vulnerable code:
```\nfunction testVaultFeeIncorrectlySet() public {\n  Dummy721 nft = new Dummy721();\n  address tokenContract = address(nft);\n  uint256 tokenId = uint256(1);\n  address publicVault = _createPublicVault({\n      strategist: strategistOne,\n      delegate: strategistTwo,\n      epochLength: 14 days\n  });\n  uint fee = PublicVault(publicVault).VAULT_FEE();\n  console.log(fee)\n  assert(fee == 5000); // 5000 is the value that was meant to be set\n}\n```\n
HIGH severity: Vulnerable function: ```\nfunction point\_mul(dst,src,s, mPtr) {\n // let mPtr := add(mload(0x40), state\_last\_mem)\n le. ```\nfunction point\_mul(dst,src,s, mPtr) {\n // let mPtr := add(mload(0x40), state\_last\_mem)\n let state := mload(0x40)\n mstore(mPtr,mload(src))\n mstore(add(mPtr,0x20),mload(add(src,0x20)))\n mstore(add(mPtr,0x40),s)\n let l\_success := staticcall(sub(gas(), 2000),7,mPtr,0x60,dst,0x40)\n mstore

Vulnerable code:
```\nfunction point\_mul(dst,src,s, mPtr) {\n // let mPtr := add(mload(0x40), state\_last\_mem)\n let state := mload(0x40)\n mstore(mPtr,mload(src))\n mstore(add(mPtr,0x20),mload(add(src,0x20)))\n mstore(add(mPtr,0x40),s)\n let l\_success := staticcall(sub(gas(), 2000),7,mPtr,0x60,dst,0x40)\n mstore(add(state, state\_success), and(l\_success,mload(add(state, state\_success))))\n}\n\n// dst <- dst + [s]src (Elliptic curve)\nfunction point\_acc\_mul(dst,src,s, mPtr) {\n let state := mload(0x40)\n mstore(mPtr,mload(src))\n mstore(add(mPtr,0x20),mload(add(src,0x20)))\n mstore(add(mPtr,0x40),s)\n let l\_success := staticcall(sub(gas(), 2000),7,mPtr,0x60,mPtr,0x40)\n mstore(add(mPtr,0x40),mload(dst))\n mstore(add(mPtr,0x60),mload(add(dst,0x20)))\n l\_success := and(l\_success, staticcall(sub(gas(), 2000),6,mPtr,0x80,dst, 0x40))\n mstore(add(state, state\_success), and(l\_success,mload(add(state, state\_success))))\n}\n```\n
MEDIUM severity: Vulnerable function: ```\n/\*\*\n \* Calculate x + y. Revert on overflow.\n \*\n \* @param x signed 64.64-bit fixed point. ```\n/\*\*\n \* Calculate x + y. Revert on overflow.\n \*\n \* @param x signed 64.64-bit fixed point number\n \* @param y signed 64.64-bit fixed point number\n \* @return signed 64.64-bit fixed point number\n \*/\nfunction add (int128 x, int128 y) internal pure returns (int128) {\n  int256 result = 

Vulnerable code:
```\n/\*\*\n \* Calculate x + y. Revert on overflow.\n \*\n \* @param x signed 64.64-bit fixed point number\n \* @param y signed 64.64-bit fixed point number\n \* @return signed 64.64-bit fixed point number\n \*/\nfunction add (int128 x, int128 y) internal pure returns (int128) {\n  int256 result = int256(x) + y;\n  require (result >= MIN\_64x64 && result <= MAX\_64x64);\n  return int128 (result);\n}\n```\n
HIGH severity: Vulnerable function: ```\n    uint256 strTokenAmt = _doBorrow(param.borrowToken, param.borrowAmount);. ```\n    uint256 strTokenAmt = _doBorrow(param.borrowToken, param.borrowAmount);\n\n    // 3. Swap borrowed token to strategy token\n    IERC20Upgradeable swapToken = ISoftVault(strategy.vault).uToken();\n    // swapData.fromAmount = strTokenAmt;\n    PSwapLib.megaSwap(augustusSwapper, tokenTransfer

Vulnerable code:
```\n    uint256 strTokenAmt = _doBorrow(param.borrowToken, param.borrowAmount);\n\n    // 3. Swap borrowed token to strategy token\n    IERC20Upgradeable swapToken = ISoftVault(strategy.vault).uToken();\n    // swapData.fromAmount = strTokenAmt;\n    PSwapLib.megaSwap(augustusSwapper, tokenTransferProxy, swapData);\n    strTokenAmt = swapToken.balanceOf(address(this)) - strTokenAmt; <- @audit-issue will always revert on swap\n```\n
MEDIUM severity: Vulnerable function: ```\n    function test_badDebtLiquidationAnte() public {\n\n        // malicious user borrows at max. ```\n    function test_badDebtLiquidationAnte() public {\n\n        // malicious user borrows at max leverage + some safety margin\n        uint256 margin0 = 1e18;\n        uint256 borrows0 = 100e18;\n\n        deal(address(asset0), address(account), margin0);\n\n        bytes memory data = abi.enco

Vulnerable code:
```\n    function test_badDebtLiquidationAnte() public {\n\n        // malicious user borrows at max leverage + some safety margin\n        uint256 margin0 = 1e18;\n        uint256 borrows0 = 100e18;\n\n        deal(address(asset0), address(account), margin0);\n\n        bytes memory data = abi.encode(Action.BORROW, borrows0, 0);\n        account.modify(this, data, (1 << 32));\n\n        // borrow increased by 50%\n        _setInterest(lender0, 15000);\n\n        emit log_named_uint("User borrow:", lender0.borrowBalance(address(account)));\n        emit log_named_uint("User assets:", asset0.balanceOf(address(account)));\n\n        // warn account\n        account.warn((1 << 32));\n\n        // skip warning time\n        skip(LIQUIDATION_GRACE_PERIOD);\n        lender0.accrueInterest();\n\n        // liquidation reverts because it requires asset the account doesn't have to swap\n        vm.expectRevert();\n        account.liquidate(this, bytes(""), 1, (1 << 32));\n\n        // liquidate with max strain to avoid revert when trying to swap assets account doesn't have\n        account.liquidate(this, bytes(""), type(uint256).max, (1 << 32));\n\n        emit log_named_uint("Liquidated User borrow:", lender0.borrowBalance(address(account)));\n        emit log_named_uint("Liquidated User assets:", asset0.balanceOf(address(account)));\n        emit log_named_uint("Liquidated User ante:", address(account).balance);\n    }\n```\n
HIGH severity: Vulnerable function: ```\nPolicyHolder storage holder = policyHolders[claimer];\n\nepochAmounts[holde. ```\nPolicyHolder storage holder = policyHolders[claimer];\n\nepochAmounts[holder.endEpochNumber] = epochAmounts[holder.endEpochNumber].sub(holder.coverTokens);\ntotalLiquidity = totalLiquidity.sub(claimAmount);\n\ndaiToken.transfer(claimer, claimAmount);\n               \ndelete policyHolders[claim

Vulnerable code:
```\nPolicyHolder storage holder = policyHolders[claimer];\n\nepochAmounts[holder.endEpochNumber] = epochAmounts[holder.endEpochNumber].sub(holder.coverTokens);\ntotalLiquidity = totalLiquidity.sub(claimAmount);\n\ndaiToken.transfer(claimer, claimAmount);\n               \ndelete policyHolders[claimer];\npolicyRegistry.removePolicy(claimer);\n```\n