Farseen0/scar-pairs huggingface dataset:
MEDIUM severity: Vulnerable function: ```\n    function openPositionFarm(\n        OpenPosParam calldata param\n    )\n        external\n . ```\n    function openPositionFarm(\n        OpenPosParam calldata param\n    )\n        external\n        existingStrategy(param.strategyId)\n        existingCollateral(param.strategyId, param.collToken)\n    {\n        // rest of code\n        // 1. Deposit isolated collaterals on Blueberry Money 

Vulnerable code:
```\n    function openPositionFarm(\n        OpenPosParam calldata param\n    )\n        external\n        existingStrategy(param.strategyId)\n        existingCollateral(param.strategyId, param.collToken)\n    {\n        // rest of code\n        // 1. Deposit isolated collaterals on Blueberry Money Market\n        _doLend(param.collToken, param.collAmount);\n\n        // 2. Borrow specific amounts\n        uint256 borrowBalance = _doBorrow(\n            param.borrowToken,\n            param.borrowAmount\n        );\n\n        // 3. Add liquidity on Balancer, get BPT\n        {\n            IBalancerVault vault = wAuraPools.getVault(lpToken);\n            _ensureApprove(param.borrowToken, address(vault), borrowBalance);\n\n            (address[] memory tokens, uint256[] memory balances, ) = wAuraPools\n                .getPoolTokens(lpToken);\n            uint[] memory maxAmountsIn = new uint[](2);\n            maxAmountsIn[0] = IERC20(tokens[0]).balanceOf(address(this));\n            maxAmountsIn[1] = IERC20(tokens[1]).balanceOf(address(this));\n\n            uint totalLPSupply = IBalancerPool(lpToken).totalSupply();\n            // compute in reverse order of how Balancer's `joinPool` computes tokenAmountIn\n            uint poolAmountFromA = (maxAmountsIn[0] * totalLPSupply) /\n                balances[0];\n            uint poolAmountFromB = (maxAmountsIn[1] * totalLPSupply) /\n                balances[1];\n            uint poolAmountOut = poolAmountFromA > poolAmountFromB\n                ? poolAmountFromB\n                : poolAmountFromA;\n\n            bytes32 poolId = bytes32(param.farmingPoolId);\n            if (poolAmountOut > 0) {\n                vault.joinPool(\n                    poolId,\n                    address(this),\n                    address(this),\n                    IBalancerVault.JoinPoolRequest(\n                        tokens,\n                        maxAmountsIn,\n                        "",\n                        false\n                    )\n                );\n            }\n        }\n        // rest of code\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction revealBid(\n    bytes32 auctionID,\n    uint256 price,\n    uint256 targetSBTAmount,\n. ```\nfunction revealBid(\n    bytes32 auctionID,\n    uint256 price,\n    uint256 targetSBTAmount,\n    uint256 random\n) public override {\n    require(\n        inRevealingValuationPeriod(auctionID),\n        "it is not the time to reveal the value of bids"\n    );\n```\n

Vulnerable code:
```\nfunction revealBid(\n    bytes32 auctionID,\n    uint256 price,\n    uint256 targetSBTAmount,\n    uint256 random\n) public override {\n    require(\n        inRevealingValuationPeriod(auctionID),\n        "it is not the time to reveal the value of bids"\n    );\n```\n
HIGH severity: Vulnerable function: ```\nfunction initialize(\n address \_securityCouncil,\n address \_messageService,\n address \_token. ```\nfunction initialize(\n address \_securityCouncil,\n address \_messageService,\n address \_tokenBeacon,\n address[] calldata \_reservedTokens\n) external initializer {\n \_\_Pausable\_init();\n \_\_Ownable\_init();\n setMessageService(\_messageService);\n tokenBeacon = \_tokenBeacon;\n for (uint

Vulnerable code:
```\nfunction initialize(\n address \_securityCouncil,\n address \_messageService,\n address \_tokenBeacon,\n address[] calldata \_reservedTokens\n) external initializer {\n \_\_Pausable\_init();\n \_\_Ownable\_init();\n setMessageService(\_messageService);\n tokenBeacon = \_tokenBeacon;\n for (uint256 i = 0; i < \_reservedTokens.length; i++) {\n setReserved(\_reservedTokens[i]);\n }\n \_transferOwnership(\_securityCouncil);\n}\n```\n
MEDIUM severity: Vulnerable function: ```\n    AccountFacetImpl.deposit(msg.sender, amount);\n    uint256 amountWith18. ```\n    AccountFacetImpl.deposit(msg.sender, amount);\n    uint256 amountWith18Decimals = (amount * 1e18) /\n        (10 ** IERC20Metadata(GlobalAppStorage.layout().collateral).decimals());\n    AccountFacetImpl.allocate(amountWith18Decimals);\n```\n

Vulnerable code:
```\n    AccountFacetImpl.deposit(msg.sender, amount);\n    uint256 amountWith18Decimals = (amount * 1e18) /\n        (10 ** IERC20Metadata(GlobalAppStorage.layout().collateral).decimals());\n    AccountFacetImpl.allocate(amountWith18Decimals);\n```\n
MEDIUM severity: Vulnerable function: ```\n    function increaseTotalSupply(uint256 _amount) private {\n        daiMock.mint(address(this). ```\n    function increaseTotalSupply(uint256 _amount) private {\n        daiMock.mint(address(this), _amount);\n        daiMock.approve(address(uToken), _amount);\n        uToken.mint(_amount);\n    }\n\n    function testMintRedeemSandwich() public {\n        increaseTotalSupply(50 ether);\n\n     

Vulnerable code:
```\n    function increaseTotalSupply(uint256 _amount) private {\n        daiMock.mint(address(this), _amount);\n        daiMock.approve(address(uToken), _amount);\n        uToken.mint(_amount);\n    }\n\n    function testMintRedeemSandwich() public {\n        increaseTotalSupply(50 ether);\n\n        vm.prank(ALICE);\n        uToken.borrow(ALICE, 50 ether);\n        uint256 borrowed = uToken.borrowBalanceView(ALICE);\n\n        vm.roll(block.number + 500);\n\n        vm.startPrank(BOB);\n        daiMock.approve(address(uToken), 100 ether);\n        uToken.mint(100 ether);\n\n        console.log("\n  [UToken] Total supply:", uToken.totalSupply());\n        console.log("[UToken] BOB balance:", uToken.balanceOf(BOB));\n        console.log("[DAI]    BOB balance:", daiMock.balanceOf(BOB));\n\n        uint256 currExchangeRate = uToken.exchangeRateStored();\n        console.log("[1] Exchange rate:", currExchangeRate);\n        vm.stopPrank();\n\n        vm.startPrank(ALICE);\n        uint256 interest = uToken.calculatingInterest(ALICE);\n        uint256 repayAmount = borrowed + interest;\n\n        daiMock.approve(address(uToken), repayAmount);\n        uToken.repayBorrow(ALICE, repayAmount);\n\n        console.log("\n  [UToken] Total supply:", uToken.totalSupply());\n        console.log("[UToken] ALICE balance:", uToken.balanceOf(ALICE));\n        console.log("[DAI]    ALICE balance:", daiMock.balanceOf(ALICE));\n\n        currExchangeRate = uToken.exchangeRateStored();\n        console.log("[2] Exchange rate:", currExchangeRate);\n        vm.stopPrank();\n\n        vm.startPrank(BOB);\n        uToken.redeem(uToken.balanceOf(BOB), 0);\n\n        console.log("\n  [UToken] Total supply:", uToken.totalSupply());\n        console.log("[UToken] BOB balance:", uToken.balanceOf(BOB));\n        console.log("[DAI]    BOB balance:", daiMock.balanceOf(BOB));\n\n        currExchangeRate = uToken.exchangeRateStored();\n        console.log("[3] Exchange rate:", currExchangeRate);\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\n   function processDeposit(GMXTypes.Store storage self) external {\n        self.depositCache.h. ```\n   function processDeposit(GMXTypes.Store storage self) external {\n        self.depositCache.healthParams.equityAfter = GMXReader.equityValue(self);\n        self.depositCache.sharesToUser = GMXReader.valueToShares(\n            self,\n            self.depositCache.healthParams.equityAfter - s

Vulnerable code:
```\n   function processDeposit(GMXTypes.Store storage self) external {\n        self.depositCache.healthParams.equityAfter = GMXReader.equityValue(self);\n        self.depositCache.sharesToUser = GMXReader.valueToShares(\n            self,\n            self.depositCache.healthParams.equityAfter - self.depositCache.healthParams.equityBefore,\n            self.depositCache.healthParams.equityBefore\n        );\n\n        GMXChecks.afterDepositChecks(self);\n    }\n    // value to shares function :\n\n     function valueToShares(GMXTypes.Store storage self, uint256 value, uint256 currentEquity)\n        public\n        view\n        returns (uint256)\n    {\n\n        uint256 _sharesSupply = IERC20(address(self.vault)).totalSupply() + pendingFee(self); // shares is added\n        if (_sharesSupply == 0 || currentEquity == 0) return value;\n        return value * _sharesSupply / currentEquity;\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction emitVotingBalances(address[] calldata accounts) external {\n    uint256 size = account. ```\nfunction emitVotingBalances(address[] calldata accounts) external {\n    uint256 size = accounts.length;\n\n    for (uint256 i = 0; i < size; ) {\n        emit DelegateVotesChanged(accounts[i], 0, getVotes(accounts[i]));\n\n        unchecked {\n            i++;\n        }\n    }\n}\n```\n

Vulnerable code:
```\nfunction emitVotingBalances(address[] calldata accounts) external {\n    uint256 size = accounts.length;\n\n    for (uint256 i = 0; i < size; ) {\n        emit DelegateVotesChanged(accounts[i], 0, getVotes(accounts[i]));\n\n        unchecked {\n            i++;\n        }\n    }\n}\n```\n
MEDIUM severity: Vulnerable function: ```\nshnarf = keccak256(\n      abi.encode(\n        shnarf,\n        _submissio. ```\nshnarf = keccak256(\n      abi.encode(\n        shnarf,\n        _submissionData.snarkHash,\n        _submissionData.finalStateRootHash,\n        compressedDataComputedX,\n        _calculateY(_submissionData.compressedData, compressedDataComputedX)\n      )\n );     \n```\n

Vulnerable code:
```\nshnarf = keccak256(\n      abi.encode(\n        shnarf,\n        _submissionData.snarkHash,\n        _submissionData.finalStateRootHash,\n        compressedDataComputedX,\n        _calculateY(_submissionData.compressedData, compressedDataComputedX)\n      )\n );     \n```\n
MEDIUM severity: Vulnerable function: ```\nmodifier checkpointProtection(address account) {\n    uint256 numCheckpoint. ```\nmodifier checkpointProtection(address account) {\n    uint256 numCheckpoints = _stakes[account]._checkpoints.length;\n    require(numCheckpoints == 0 || _stakes[account]._checkpoints[numCheckpoints - 1]._blockNumber != block.number, "StakingModule: Cannot exit in the same block as another stake

Vulnerable code:
```\nmodifier checkpointProtection(address account) {\n    uint256 numCheckpoints = _stakes[account]._checkpoints.length;\n    require(numCheckpoints == 0 || _stakes[account]._checkpoints[numCheckpoints - 1]._blockNumber != block.number, "StakingModule: Cannot exit in the same block as another stake or exit");\n    _;\n}\n```\n
HIGH severity: Vulnerable function: ```\nfunction \_updateWithdrawalQueue() internal {\n  uint256 \_availableLiquidity = totalLiquidity.. ```\nfunction \_updateWithdrawalQueue() internal {\n  uint256 \_availableLiquidity = totalLiquidity.sub(totalCoverTokens);\n  uint256 \_countToRemoveFromQueue;\n\n  for (uint256 i = 0; i < withdrawalQueue.length; i++) {     \n    uint256 \_tokensToWithdraw = withdrawalsInfo[withdrawalQueue[i]].amoun

Vulnerable code:
```\nfunction \_updateWithdrawalQueue() internal {\n  uint256 \_availableLiquidity = totalLiquidity.sub(totalCoverTokens);\n  uint256 \_countToRemoveFromQueue;\n\n  for (uint256 i = 0; i < withdrawalQueue.length; i++) {     \n    uint256 \_tokensToWithdraw = withdrawalsInfo[withdrawalQueue[i]].amount;\n    uint256 \_amountInDai = \_tokensToWithdraw.mul(getDAIToDAIxRatio()).div(PERCENTAGE\_100);\n\n    if (balanceOf(withdrawalQueue[i]) < \_tokensToWithdraw) {\n      \_countToRemoveFromQueue++;\n      continue;\n    }\n\n    if (\_availableLiquidity >= \_amountInDai) {\n      \_withdrawLiquidity(withdrawalQueue[i], \_tokensToWithdraw);\n      \_availableLiquidity = \_availableLiquidity.sub(\_amountInDai);\n      \_countToRemoveFromQueue++;\n    } else {\n      break;\n    }\n  }\n\n  \_removeFromQueue(\_countToRemoveFromQueue);\n}\n```\n
MEDIUM severity: Vulnerable function: ```\nstruct Collateral {\n    CollateralType _collateralType;\n    uint256 _amou. ```\nstruct Collateral {\n    CollateralType _collateralType;\n    uint256 _amount;\n    uint256 _tokenId;\n    address _collateralAddress;\n}\n```\n

Vulnerable code:
```\nstruct Collateral {\n    CollateralType _collateralType;\n    uint256 _amount;\n    uint256 _tokenId;\n    address _collateralAddress;\n}\n```\n
MEDIUM severity: Vulnerable function: ```\nuint256[] memory wire\_committed\_commitments = new uint256[](2\*vk\_nb\_co. ```\nuint256[] memory wire\_committed\_commitments = new uint256[](2\*vk\_nb\_commitments\_commit\_api);\nload\_wire\_commitments\_commit\_api(wire\_committed\_commitments, proof);\n```\n

Vulnerable code:
```\nuint256[] memory wire\_committed\_commitments = new uint256[](2\*vk\_nb\_commitments\_commit\_api);\nload\_wire\_commitments\_commit\_api(wire\_committed\_commitments, proof);\n```\n
HIGH severity: Vulnerable function: ```\n                uint256 feesAmt = FullMath.mulDiv(feesOwed, cache.holdToken. ```\n                uint256 feesAmt = FullMath.mulDiv(feesOwed, cache.holdTokenDebt, borrowedAmount); //fees owed multiplied by the individual amount lent, divided by the total amount lent\n                // rest of code\n                loansFeesInfo[creditor][cache.holdToken] += feesAmt;\n      

Vulnerable code:
```\n                uint256 feesAmt = FullMath.mulDiv(feesOwed, cache.holdTokenDebt, borrowedAmount); //fees owed multiplied by the individual amount lent, divided by the total amount lent\n                // rest of code\n                loansFeesInfo[creditor][cache.holdToken] += feesAmt;\n                harvestedAmt += feesAmt;\n```\n
HIGH severity: Vulnerable function: ```\nfunction _commitRequested(OracleVersion memory version) private returns (bool) {\n    if (block. ```\nfunction _commitRequested(OracleVersion memory version) private returns (bool) {\n    if (block.timestamp <= (next() + timeout)) {\n        if (!version.valid) revert KeeperOracleInvalidPriceError();\n        _prices[version.timestamp] = version.price;\n    } else {\n        // @audit previous 

Vulnerable code:
```\nfunction _commitRequested(OracleVersion memory version) private returns (bool) {\n    if (block.timestamp <= (next() + timeout)) {\n        if (!version.valid) revert KeeperOracleInvalidPriceError();\n        _prices[version.timestamp] = version.price;\n    } else {\n        // @audit previous valid version's price is set for expired version\n        _prices[version.timestamp] = _prices[_global.latestVersion]; \n    }\n    _global.latestIndex++;\n    return true;\n}\n```\n
MEDIUM severity: Vulnerable function: ```\n      uint256[] memory balances = vlt.balances();\n          //ensure depos. ```\n      uint256[] memory balances = vlt.balances();\n          //ensure deposits are in the same ratios as the vault's current balances\n          require(functions.ratiosMatch(balances, amts), "ratios don't match");\n```\n

Vulnerable code:
```\n      uint256[] memory balances = vlt.balances();\n          //ensure deposits are in the same ratios as the vault's current balances\n          require(functions.ratiosMatch(balances, amts), "ratios don't match");\n```\n
MEDIUM severity: Vulnerable function: ```\nFile: LiquidationFacetImpl.sol\n    function liquidatePartyB(\n..SNIP..\n        if (uint256(-a. ```\nFile: LiquidationFacetImpl.sol\n    function liquidatePartyB(\n..SNIP..\n        if (uint256(-availableBalance) < accountLayout.partyBLockedBalances[partyB][partyA].lf) {\n            remainingLf =\n                accountLayout.partyBLockedBalances[partyB][partyA].lf -\n                uint256

Vulnerable code:
```\nFile: LiquidationFacetImpl.sol\n    function liquidatePartyB(\n..SNIP..\n        if (uint256(-availableBalance) < accountLayout.partyBLockedBalances[partyB][partyA].lf) {\n            remainingLf =\n                accountLayout.partyBLockedBalances[partyB][partyA].lf -\n                uint256(-availableBalance);\n            liquidatorShare = (remainingLf * maLayout.liquidatorShare) / 1e18;\n\n            maLayout.partyBPositionLiquidatorsShare[partyB][partyA] =\n                (remainingLf - liquidatorShare) /\n                quoteLayout.partyBPositionsCount[partyB][partyA];\n        } else {\n            maLayout.partyBPositionLiquidatorsShare[partyB][partyA] = 0;\n        }\n```\n
HIGH severity: Vulnerable function: ```\n      user.amount = _amt;\n      user.rewardDebt = (_amt * pool.accRewardPe. ```\n      user.amount = _amt;\n      user.rewardDebt = (_amt * pool.accRewardPerShare) / ACC_TOKEN_PRECISION;\n      user.rewardsOwed = rewardsOwed;\n```\n

Vulnerable code:
```\n      user.amount = _amt;\n      user.rewardDebt = (_amt * pool.accRewardPerShare) / ACC_TOKEN_PRECISION;\n      user.rewardsOwed = rewardsOwed;\n```\n
MEDIUM severity: Vulnerable function: ```\n  bytes32 lsp1typeIdDelegateKey = LSP2Utils.generateMappingKey(\n  _LSP1_UN. ```\n  bytes32 lsp1typeIdDelegateKey = LSP2Utils.generateMappingKey(\n  _LSP1_UNIVERSAL_RECEIVER_DELEGATE_PREFIX, bytes20(typeId));\n```\n

Vulnerable code:
```\n  bytes32 lsp1typeIdDelegateKey = LSP2Utils.generateMappingKey(\n  _LSP1_UNIVERSAL_RECEIVER_DELEGATE_PREFIX, bytes20(typeId));\n```\n
HIGH severity: Vulnerable function: ```\n    if (cliff < totalCliffs) {\n        /// e.g. (new) reduction = (500 - 1. ```\n    if (cliff < totalCliffs) {\n        /// e.g. (new) reduction = (500 - 100) * 2.5 + 700 = 1700;\n        /// e.g. (new) reduction = (500 - 250) * 2.5 + 700 = 1325;\n        /// e.g. (new) reduction = (500 - 400) * 2.5 + 700 = 950;\n        uint256 reduction = ((totalCliffs - cliff) * 5) / 2 

Vulnerable code:
```\n    if (cliff < totalCliffs) {\n        /// e.g. (new) reduction = (500 - 100) * 2.5 + 700 = 1700;\n        /// e.g. (new) reduction = (500 - 250) * 2.5 + 700 = 1325;\n        /// e.g. (new) reduction = (500 - 400) * 2.5 + 700 = 950;\n        uint256 reduction = ((totalCliffs - cliff) * 5) / 2 + 700;\n        /// e.g. (new) amount = 1e19 * 1700 / 500 =  34e18;\n        /// e.g. (new) amount = 1e19 * 1325 / 500 =  26.5e18;\n        /// e.g. (new) amount = 1e19 * 950 / 500  =  19e17;\n        mintAmount = (mintRequestAmount * reduction) / totalCliffs;\n\n        /// e.g. amtTillMax = 5e25 - 1e25 = 4e25\n        uint256 amtTillMax = emissionMaxSupply - emissionsMinted;\n        if (mintAmount > amtTillMax) {\n            mintAmount = amtTillMax;\n        }\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction \_generateGroup(bytes32 schainId, uint numberOfNodes) private returns (uint[] memory n. ```\nfunction \_generateGroup(bytes32 schainId, uint numberOfNodes) private returns (uint[] memory nodesInGroup) {\n    Nodes nodes = Nodes(contractManager.getContract("Nodes"));\n    uint8 space = schains[schainId].partOfNode;\n    nodesInGroup = new uint[](numberOfNodes);\n\n    uint[] memory poss

Vulnerable code:
```\nfunction \_generateGroup(bytes32 schainId, uint numberOfNodes) private returns (uint[] memory nodesInGroup) {\n    Nodes nodes = Nodes(contractManager.getContract("Nodes"));\n    uint8 space = schains[schainId].partOfNode;\n    nodesInGroup = new uint[](numberOfNodes);\n\n    uint[] memory possibleNodes = isEnoughNodes(schainId);\n    require(possibleNodes.length >= nodesInGroup.length, "Not enough nodes to create Schain");\n    uint ignoringTail = 0;\n    uint random = uint(keccak256(abi.encodePacked(uint(blockhash(block.number.sub(1))), schainId)));\n    for (uint i = 0; i < nodesInGroup.length; ++i) {\n        uint index = random % (possibleNodes.length.sub(ignoringTail));\n        uint node = possibleNodes[index];\n        nodesInGroup[i] = node;\n        \_swap(possibleNodes, index, possibleNodes.length.sub(ignoringTail).sub(1));\n        ++ignoringTail;\n\n        \_exceptionsForGroups[schainId][node] = true;\n        addSchainForNode(node, schainId);\n        require(nodes.removeSpaceFromNode(node, space), "Could not remove space from Node");\n    }\n```\n
HIGH severity: Vulnerable function: ```\nfunction rebalance(\n    uint256 amount,\n    uint256 amountOutMinimum,\n    uint160 sqrtPriceL. ```\nfunction rebalance(\n    uint256 amount,\n    uint256 amountOutMinimum,\n    uint160 sqrtPriceLimitX96,\n    uint24 swapPoolFee,\n    int8 polarity,\n    address account // @audit user specified payer\n) external nonReentrant returns (uint256, uint256) {\n    if (polarity == -1) {\n        retu

Vulnerable code:
```\nfunction rebalance(\n    uint256 amount,\n    uint256 amountOutMinimum,\n    uint160 sqrtPriceLimitX96,\n    uint24 swapPoolFee,\n    int8 polarity,\n    address account // @audit user specified payer\n) external nonReentrant returns (uint256, uint256) {\n    if (polarity == -1) {\n        return\n            _rebalanceNegativePnlWithSwap(\n                amount,\n                amountOutMinimum,\n                sqrtPriceLimitX96,\n                swapPoolFee,\n                account // @audit user address passed directly\n            );\n    } else if (polarity == 1) {\n        // disable rebalancing positive PnL\n        revert PositivePnlRebalanceDisabled(msg.sender);\n        // return _rebalancePositivePnlWithSwap(amount, amountOutMinimum, sqrtPriceLimitX96, swapPoolFee, account);\n    } else {\n        revert InvalidRebalance(polarity);\n    }\n}\n```\n
MEDIUM severity: Vulnerable function: ```\nFile: flatcoin-v1\src\LeverageModule.sol\n    function executeOpen(\n        address _account,\. ```\nFile: flatcoin-v1\src\LeverageModule.sol\n    function executeOpen(\n        address _account,\n        address _keeper,\n        FlatcoinStructs.Order calldata _order\n    ) external whenNotPaused onlyAuthorizedModule returns (uint256 _newTokenId) {\n// rest of code// rest of code\n101:->     

Vulnerable code:
```\nFile: flatcoin-v1\src\LeverageModule.sol\n    function executeOpen(\n        address _account,\n        address _keeper,\n        FlatcoinStructs.Order calldata _order\n    ) external whenNotPaused onlyAuthorizedModule returns (uint256 _newTokenId) {\n// rest of code// rest of code\n101:->       vault.checkSkewMax({additionalSkew: announcedOpen.additionalSize});\n\n        {\n            // The margin change is equal to funding fees accrued to longs and the margin deposited by the trader.\n105:->           vault.updateGlobalPositionData({\n                price: entryPrice,\n                marginDelta: int256(announcedOpen.margin),\n                additionalSizeDelta: int256(announcedOpen.additionalSize)\n            });\n// rest of code// rest of code\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\n    /**\n     * @notice Migrate owner of vesting. Used when user lost his p. ```\n    /**\n     * @notice Migrate owner of vesting. Used when user lost his private key\n     * @dev Only admin can migrate users vesting\n     * @param categoryId Category id\n     * @param vestingId Vesting id\n     * @param prevUser previous user address\n     * @param newUser new user address

Vulnerable code:
```\n    /**\n     * @notice Migrate owner of vesting. Used when user lost his private key\n     * @dev Only admin can migrate users vesting\n     * @param categoryId Category id\n     * @param vestingId Vesting id\n     * @param prevUser previous user address\n     * @param newUser new user address\n     */\n```\n
MEDIUM severity: Vulnerable function: ```\n⇒ solidity-shell\n\n🚀 Entering interactive Solidity ^0.8.11 shell. '.help' . ```\n⇒ solidity-shell\n\n🚀 Entering interactive Solidity ^0.8.11 shell. '.help' and '.exit' are your friends.\n » ℹ️ ganache-mgr: starting temp. ganache instance // rest of code\n » uint(int(-100))\n115792089237316195423570985008687907853269984665640564039457584007913129639836\n » int256(uint(2\*\*2

Vulnerable code:
```\n⇒ solidity-shell\n\n🚀 Entering interactive Solidity ^0.8.11 shell. '.help' and '.exit' are your friends.\n » ℹ️ ganache-mgr: starting temp. ganache instance // rest of code\n » uint(int(-100))\n115792089237316195423570985008687907853269984665640564039457584007913129639836\n » int256(uint(2\*\*256-100))\n-100\n```\n