Farseen0/scar-pairs huggingface dataset:
MEDIUM severity: Vulnerable function: ```\n  function setProposalThreshold(uint256 newProposalThreshold) external {\n    if(msg.sender != . ```\n  function setProposalThreshold(uint256 newProposalThreshold) external {\n    if(msg.sender != multisig) revert NotMultisig();\n    if(newProposalThreshold < MIN_PROPOSAL_THRESHOLD || newProposalThreshold > MAX_PROPOSAL_THRESHOLD) revert InvalidVotingParameter();\n    uint256 oldProposalThresho

Vulnerable code:
```\n  function setProposalThreshold(uint256 newProposalThreshold) external {\n    if(msg.sender != multisig) revert NotMultisig();\n    if(newProposalThreshold < MIN_PROPOSAL_THRESHOLD || newProposalThreshold > MAX_PROPOSAL_THRESHOLD) revert InvalidVotingParameter();\n    uint256 oldProposalThreshold = proposalThreshold;\n    proposalThreshold = newProposalThreshold;\n    emit ProposalThresholdSet(oldProposalThreshold, proposalThreshold);\n  }\n```\n
MEDIUM severity: Vulnerable function: ```\nFile: TellorOracle.sol\n    function getPriceInEth(address tokenToPrice) external returns (uint. ```\nFile: TellorOracle.sol\n    function getPriceInEth(address tokenToPrice) external returns (uint256) {\n        TellorInfo memory tellorInfo = _getQueryInfo(tokenToPrice);\n        uint256 timestamp = block.timestamp;\n        // Giving time for Tellor network to dispute price\n        (bytes me

Vulnerable code:
```\nFile: TellorOracle.sol\n    function getPriceInEth(address tokenToPrice) external returns (uint256) {\n        TellorInfo memory tellorInfo = _getQueryInfo(tokenToPrice);\n        uint256 timestamp = block.timestamp;\n        // Giving time for Tellor network to dispute price\n        (bytes memory value, uint256 timestampRetrieved) = getDataBefore(tellorInfo.queryId, timestamp - 30 minutes);\n        uint256 tellorStoredTimeout = uint256(tellorInfo.pricingTimeout);\n        uint256 tokenPricingTimeout = tellorStoredTimeout == 0 ? DEFAULT_PRICING_TIMEOUT : tellorStoredTimeout;\n\n        // Check that something was returned and freshness of price.\n        if (timestampRetrieved == 0 || timestamp - timestampRetrieved > tokenPricingTimeout) {\n            revert InvalidDataReturned();\n        }\n\n        uint256 price = abi.decode(value, (uint256));\n        return _denominationPricing(tellorInfo.denomination, price, tokenToPrice);\n    }\n```\n
HIGH severity: Vulnerable function: ```\nfunction getReward(address _account, bool _claimExtras) public updateReward(_account) returns(b. ```\nfunction getReward(address _account, bool _claimExtras) public updateReward(_account) returns(bool){\n    uint256 reward = earned(_account);\n    if (reward > 0) {\n        rewards[_account] = 0;\n        rewardToken.safeTransfer(_account, reward);\n        IDeposit(operator).rewardClaimed(pid,

Vulnerable code:
```\nfunction getReward(address _account, bool _claimExtras) public updateReward(_account) returns(bool){\n    uint256 reward = earned(_account);\n    if (reward > 0) {\n        rewards[_account] = 0;\n        rewardToken.safeTransfer(_account, reward);\n        IDeposit(operator).rewardClaimed(pid, _account, reward);\n        emit RewardPaid(_account, reward);\n    }\n\n    //also get rewards from linked rewards\n    if(_claimExtras){\n        for(uint i=0; i < extraRewards.length; i++){\n            IRewards(extraRewards[i]).getReward(_account);\n        }\n    }\n    return true;\n}\n```\n
HIGH severity: Vulnerable function: ```\n         if (D == 0) { //initial deposit\n                   uint256 sumDen. ```\n         if (D == 0) { //initial deposit\n                   uint256 sumDenoms = 0; \n                        for (uint256 i = 0; i < tkns.length; i++) {\n                              sumDenoms += \n                        AI.getAllowedTokenInfo(tkns[i]).initialDenominator;\n                  

Vulnerable code:
```\n         if (D == 0) { //initial deposit\n                   uint256 sumDenoms = 0; \n                        for (uint256 i = 0; i < tkns.length; i++) {\n                              sumDenoms += \n                        AI.getAllowedTokenInfo(tkns[i]).initialDenominator;\n                      }\n                   require(sumDenoms > 0 && sumDenoms <= maxInitialDenominator, \n         "invalid sumDenoms");\n                   deltaN = sumDenoms; //initial numerator and denominator are the \n                same, and are greater than any possible balance in the vault.\n             //this ensures precision in the vault's \n         balances. User Balance = (N*T)/D will have rounding errors always 1 \n         wei or less. \n         } else { \n            // deltaN = (amt * D)/T;\n            deltaN = Arithmetic.overflowResistantFraction(amt, D, T);\n         }\n```\n
HIGH severity: Vulnerable function: ```\nfunction \_slippageIsValid(Batch storage \_batch, address \_collateral) internal view returns (. ```\nfunction \_slippageIsValid(Batch storage \_batch, address \_collateral) internal view returns (bool) {\n    uint256 staticPricePPM = \_staticPricePPM(\_batch.supply, \_batch.balance, \_batch.reserveRatio);\n    uint256 maximumSlippage = collaterals[\_collateral].slippage;\n```\n

Vulnerable code:
```\nfunction \_slippageIsValid(Batch storage \_batch, address \_collateral) internal view returns (bool) {\n    uint256 staticPricePPM = \_staticPricePPM(\_batch.supply, \_batch.balance, \_batch.reserveRatio);\n    uint256 maximumSlippage = collaterals[\_collateral].slippage;\n```\n
MEDIUM severity: Vulnerable function: ```\nFile: ProportionalRebalancingStrategy.sol\n        for (uint256 i; i < hold. ```\nFile: ProportionalRebalancingStrategy.sol\n        for (uint256 i; i < holdings.length;) {\n            address holding = holdings[i];\n            uint256 targetAmount = totalValue * rebalancingTargets[i] / uint256(Constants.PERCENTAGE_DECIMALS);\n            uint256 currentAmount = values[i];

Vulnerable code:
```\nFile: ProportionalRebalancingStrategy.sol\n        for (uint256 i; i < holdings.length;) {\n            address holding = holdings[i];\n            uint256 targetAmount = totalValue * rebalancingTargets[i] / uint256(Constants.PERCENTAGE_DECIMALS);\n            uint256 currentAmount = values[i];\n\n            redeemHoldings[i] = holding;\n            depositHoldings[i] = holding;\n\n            if (targetAmount < currentAmount) {\n                unchecked {\n                    redeemAmounts[i] = currentAmount - targetAmount;\n                }\n            } else if (currentAmount < targetAmount) {\n                unchecked {\n                    depositAmounts[i] = targetAmount - currentAmount;\n                }\n            }\n\n            unchecked {\n                ++i;\n            }\n        }\n```\n
HIGH severity: Vulnerable function: ```\n  function lock(uint256 amount) external {\n    uint256 mintAmount = _GiBGTMintAmount(amount);\. ```\n  function lock(uint256 amount) external {\n    uint256 mintAmount = _GiBGTMintAmount(amount);\n    poolSize += amount;\n    _refreshiBGT(amount); //@audit should call after depositing funds\n    SafeTransferLib.safeTransferFrom(ibgt, msg.sender, address(this), amount);\n    _mint(msg.sender, m

Vulnerable code:
```\n  function lock(uint256 amount) external {\n    uint256 mintAmount = _GiBGTMintAmount(amount);\n    poolSize += amount;\n    _refreshiBGT(amount); //@audit should call after depositing funds\n    SafeTransferLib.safeTransferFrom(ibgt, msg.sender, address(this), amount);\n    _mint(msg.sender, mintAmount);\n    emit iBGTLock(msg.sender, amount);\n  }\n// rest of code\n  function _refreshiBGT(uint256 ibgtAmount) internal {\n    ERC20(ibgt).approve(ibgtVault, ibgtAmount);\n    iBGTVault(ibgtVault).stake(ibgtAmount); //@audit will revert here\n  }\n```\n
MEDIUM severity: Vulnerable function: ```\nrequestLoan("1,000 debt tokens", "5% interest", "10 loan tokens for each co. ```\nrequestLoan("1,000 debt tokens", "5% interest", "10 loan tokens for each collateral", "1 year")\n```\n

Vulnerable code:
```\nrequestLoan("1,000 debt tokens", "5% interest", "10 loan tokens for each collateral", "1 year")\n```\n
HIGH severity: Vulnerable function: ```\nfunction mint(uint256 pid, uint256 amount)\n    external\n    nonReentrant\n    returns (uint25. ```\nfunction mint(uint256 pid, uint256 amount)\n    external\n    nonReentrant\n    returns (uint256)\n{\n    address lpToken = ichiFarm.lpToken(pid);\n    IERC20Upgradeable(lpToken).safeTransferFrom(\n        msg.sender,\n        address(this),\n        amount\n    );\n    if (\n        IERC20Upgr

Vulnerable code:
```\nfunction mint(uint256 pid, uint256 amount)\n    external\n    nonReentrant\n    returns (uint256)\n{\n    address lpToken = ichiFarm.lpToken(pid);\n    IERC20Upgradeable(lpToken).safeTransferFrom(\n        msg.sender,\n        address(this),\n        amount\n    );\n    if (\n        IERC20Upgradeable(lpToken).allowance(\n            address(this),\n            address(ichiFarm)\n        ) != type(uint256).max\n    ) {\n        // We only need to do this once per pool, as LP token's allowance won't decrease if it's -1.\n        IERC20Upgradeable(lpToken).safeApprove(\n            address(ichiFarm),\n            type(uint256).max\n        );\n    }\n    ichiFarm.deposit(pid, amount, address(this));\n    // @ok if accIchiPerShare is always changing, so how does this work?\n    // it's basically just saving the accIchiPerShare at staking time, so when you unstake, it can calculate the difference\n    // really fucking smart actually\n    (uint256 ichiPerShare, , ) = ichiFarm.poolInfo(pid);\n    uint256 id = encodeId(pid, ichiPerShare);\n    _mint(msg.sender, id, amount, "");\n    return id;\n}\n```\n
HIGH severity: Vulnerable function: ```\n\_settleRedemption(\_recipient, \_mAssetQuantity, props.bAssets, bAssetQuan. ```\n\_settleRedemption(\_recipient, \_mAssetQuantity, props.bAssets, bAssetQuantities, props.indexes, props.integrators, false);\n```\n

Vulnerable code:
```\n\_settleRedemption(\_recipient, \_mAssetQuantity, props.bAssets, bAssetQuantities, props.indexes, props.integrators, false);\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction setPayoutScheduleFixed(\n        uint256[] calldata _payoutSchedule,\n        address . ```\nfunction setPayoutScheduleFixed(\n        uint256[] calldata _payoutSchedule,\n        address _payoutTokenAddress\n    ) external onlyOpenQ {\n        require(\n            bountyType == OpenQDefinitions.TIERED_FIXED,\n            Errors.NOT_A_FIXED_TIERED_BOUNTY\n        );\n        payoutSch

Vulnerable code:
```\nfunction setPayoutScheduleFixed(\n        uint256[] calldata _payoutSchedule,\n        address _payoutTokenAddress\n    ) external onlyOpenQ {\n        require(\n            bountyType == OpenQDefinitions.TIERED_FIXED,\n            Errors.NOT_A_FIXED_TIERED_BOUNTY\n        );\n        payoutSchedule = _payoutSchedule;\n        payoutTokenAddress = _payoutTokenAddress;\n\n        // Resize metadata arrays and copy current members to new array\n        // NOTE: If resizing to fewer tiers than previously, the final indexes will be removed\n        string[] memory newTierWinners = new string[](payoutSchedule.length);\n        bool[] memory newInvoiceComplete = new bool[](payoutSchedule.length);\n        bool[] memory newSupportingDocumentsCompleted = new bool[](\n            payoutSchedule.length\n        );\n\n        for (uint256 i = 0; i < tierWinners.length; i++) { <=====================================================\n            newTierWinners[i] = tierWinners[i];\n        }\n        tierWinners = newTierWinners;\n\n        for (uint256 i = 0; i < invoiceComplete.length; i++) { <=====================================================\n            newInvoiceComplete[i] = invoiceComplete[i];\n        }\n        invoiceComplete = newInvoiceComplete;\n\n        for (uint256 i = 0; i < supportingDocumentsComplete.length; i++) { <=====================================================\n            newSupportingDocumentsCompleted[i] = supportingDocumentsComplete[i];\n        }\n        supportingDocumentsComplete = newSupportingDocumentsCompleted;\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\n        IERC20(USDC).approve(jusdExchange, borrowBalance);\n        IJUSDEx. ```\n        IERC20(USDC).approve(jusdExchange, borrowBalance);\n        IJUSDExchange(jusdExchange).buyJUSD(borrowBalance, address(this));\n        IERC20(USDC).safeTransfer(to, USDCAmount - borrowBalance);\n        JUSDAmount = borrowBalance;\n    }\n```\n

Vulnerable code:
```\n        IERC20(USDC).approve(jusdExchange, borrowBalance);\n        IJUSDExchange(jusdExchange).buyJUSD(borrowBalance, address(this));\n        IERC20(USDC).safeTransfer(to, USDCAmount - borrowBalance);\n        JUSDAmount = borrowBalance;\n    }\n```\n
HIGH severity: Vulnerable function: ```\nfunction supplyNativeToken(address user) internal nonReentrant {\n    WethInterface(weth).depos. ```\nfunction supplyNativeToken(address user) internal nonReentrant {\n    WethInterface(weth).deposit{value: msg.value}();\n    IERC20(weth).safeIncreaseAllowance(address(ironBank), msg.value);\n    ironBank.supply(address(this), user, weth, msg.value);\n}\n```\n

Vulnerable code:
```\nfunction supplyNativeToken(address user) internal nonReentrant {\n    WethInterface(weth).deposit{value: msg.value}();\n    IERC20(weth).safeIncreaseAllowance(address(ironBank), msg.value);\n    ironBank.supply(address(this), user, weth, msg.value);\n}\n```\n
HIGH severity: Vulnerable function: ```\nuint256 tradeFee = ILeverageModule(vault.moduleAddress(FlatcoinModuleKeys._. ```\nuint256 tradeFee = ILeverageModule(vault.moduleAddress(FlatcoinModuleKeys._LEVERAGE_MODULE_KEY)).getTradeFee(\n    vault.getPosition(tokenId).additionalSize\n);\n```\n

Vulnerable code:
```\nuint256 tradeFee = ILeverageModule(vault.moduleAddress(FlatcoinModuleKeys._LEVERAGE_MODULE_KEY)).getTradeFee(\n    vault.getPosition(tokenId).additionalSize\n);\n```\n
MEDIUM severity: Vulnerable function: ```\nburnFrom(from, amountFGEN);\ncommittedFGEN[from] = 0;\n\npayable(to).transf. ```\nburnFrom(from, amountFGEN);\ncommittedFGEN[from] = 0;\n\npayable(to).transfer(total);\n```\n

Vulnerable code:
```\nburnFrom(from, amountFGEN);\ncommittedFGEN[from] = 0;\n\npayable(to).transfer(total);\n```\n
HIGH severity: Vulnerable function: ```\n    function SetZauction(address zauctionaddress) external onlyAdmin{\n        zauction = zauct. ```\n    function SetZauction(address zauctionaddress) external onlyAdmin{\n        zauction = zauctionaddress;\n        emit ZauctionSet(zauctionaddress);\n    }\n\n    function SetAdmin(address newadmin) external onlyAdmin{\n        admin = newadmin;\n        emit AdminSet(msg.sender, newadmin);\n

Vulnerable code:
```\n    function SetZauction(address zauctionaddress) external onlyAdmin{\n        zauction = zauctionaddress;\n        emit ZauctionSet(zauctionaddress);\n    }\n\n    function SetAdmin(address newadmin) external onlyAdmin{\n        admin = newadmin;\n        emit AdminSet(msg.sender, newadmin);\n    }\n```\n
HIGH severity: Vulnerable function: ```\nfunction supplyTokenTo(uint256 \_amount, address to) override external {\n    uint256 shares = . ```\nfunction supplyTokenTo(uint256 \_amount, address to) override external {\n    uint256 shares = \_tokenToShares(\_amount);\n\n    \_mint(to, shares);\n\n    // NOTE: we have to deposit after calculating shares to mint\n    token.safeTransferFrom(msg.sender, address(this), \_amount);\n\n    \_dep

Vulnerable code:
```\nfunction supplyTokenTo(uint256 \_amount, address to) override external {\n    uint256 shares = \_tokenToShares(\_amount);\n\n    \_mint(to, shares);\n\n    // NOTE: we have to deposit after calculating shares to mint\n    token.safeTransferFrom(msg.sender, address(this), \_amount);\n\n    \_depositInVault();\n\n    emit SuppliedTokenTo(msg.sender, shares, \_amount, to);\n}\n```\n
HIGH severity: Vulnerable function: ```\nfunction _validateMaxLTV(uint256 strategyId) internal view {\n    uint256 debtValue = bank.getD. ```\nfunction _validateMaxLTV(uint256 strategyId) internal view {\n    uint256 debtValue = bank.getDebtValue(bank.POSITION_ID());\n    (, address collToken, uint256 collAmount, , , , , ) = bank\n        .getCurrentPositionInfo();\n    uint256 collPrice = bank.oracle().getPrice(collToken);\n    uint2

Vulnerable code:
```\nfunction _validateMaxLTV(uint256 strategyId) internal view {\n    uint256 debtValue = bank.getDebtValue(bank.POSITION_ID());\n    (, address collToken, uint256 collAmount, , , , , ) = bank\n        .getCurrentPositionInfo();\n    uint256 collPrice = bank.oracle().getPrice(collToken);\n    uint256 collValue = (collPrice * collAmount) /\n        10**IERC20Metadata(collToken).decimals();\n\n    if (\n        debtValue >\n        (collValue * maxLTV[strategyId][collToken]) / DENOMINATOR\n    ) revert EXCEED_MAX_LTV();\n}\n```\n
HIGH severity: Vulnerable function: ```\nfunction claim(\n uint256 policyIndex\_,\n uint256 amount\_,\n address receipient\_\n) external. ```\nfunction claim(\n uint256 policyIndex\_,\n uint256 amount\_,\n address receipient\_\n) external onlyPoolManager {\n```\n

Vulnerable code:
```\nfunction claim(\n uint256 policyIndex\_,\n uint256 amount\_,\n address receipient\_\n) external onlyPoolManager {\n```\n
MEDIUM severity: Vulnerable function: ```\nIAccount(account).updateActionTimestampByCreditor();\n\nasset.safeTransfer(. ```\nIAccount(account).updateActionTimestampByCreditor();\n\nasset.safeTransfer(actionTarget, amountBorrowed);\n\n{\n    uint256 accountVersion = IAccount(account).flashActionByCreditor(actionTarget, actionData);\n    if (!isValidVersion[accountVersion]) revert LendingPoolErrors.InvalidVersion();\n}

Vulnerable code:
```\nIAccount(account).updateActionTimestampByCreditor();\n\nasset.safeTransfer(actionTarget, amountBorrowed);\n\n{\n    uint256 accountVersion = IAccount(account).flashActionByCreditor(actionTarget, actionData);\n    if (!isValidVersion[accountVersion]) revert LendingPoolErrors.InvalidVersion();\n}\n```\n
HIGH severity: Vulnerable function: ```\nfunction verify(\n    bytes calldata inputTxBytes,\n    uint16 outputIndex,\n    uint256 inputT. ```\nfunction verify(\n    bytes calldata inputTxBytes,\n    uint16 outputIndex,\n    uint256 inputTxPos,\n    bytes calldata spendingTxBytes,\n    uint16 inputIndex,\n    bytes calldata signature,\n    bytes calldata /\*optionalArgs\*/\n)\n    external\n    view\n    returns (bool)\n{\n    PaymentT

Vulnerable code:
```\nfunction verify(\n    bytes calldata inputTxBytes,\n    uint16 outputIndex,\n    uint256 inputTxPos,\n    bytes calldata spendingTxBytes,\n    uint16 inputIndex,\n    bytes calldata signature,\n    bytes calldata /\*optionalArgs\*/\n)\n    external\n    view\n    returns (bool)\n{\n    PaymentTransactionModel.Transaction memory inputTx = PaymentTransactionModel.decode(inputTxBytes);\n    require(inputTx.txType == supportInputTxType, "Input tx is an unsupported payment tx type");\n\n    PaymentTransactionModel.Transaction memory spendingTx = PaymentTransactionModel.decode(spendingTxBytes);\n    require(spendingTx.txType == supportSpendingTxType, "The spending tx is an unsupported payment tx type");\n\n    UtxoPosLib.UtxoPos memory utxoPos = UtxoPosLib.build(TxPosLib.TxPos(inputTxPos), outputIndex);\n    require(\n        spendingTx.inputs[inputIndex] == bytes32(utxoPos.value),\n        "Spending tx points to the incorrect output UTXO position"\n    );\n\n    address payable owner = inputTx.outputs[outputIndex].owner();\n    require(owner == ECDSA.recover(eip712.hashTx(spendingTx), signature), "Tx in not signed correctly");\n\n    return true;\n}\n```\n
HIGH severity: Vulnerable function: ```\nFile: Stable2TokenOracleMath.sol\n    function _validateSpotPriceAndPairPrice(\n        StableO. ```\nFile: Stable2TokenOracleMath.sol\n    function _validateSpotPriceAndPairPrice(\n        StableOracleContext calldata oracleContext,\n        TwoTokenPoolContext calldata poolContext,\n        StrategyContext memory strategyContext,\n        uint256 oraclePrice,\n        uint256 primaryAmount, \

Vulnerable code:
```\nFile: Stable2TokenOracleMath.sol\n    function _validateSpotPriceAndPairPrice(\n        StableOracleContext calldata oracleContext,\n        TwoTokenPoolContext calldata poolContext,\n        StrategyContext memory strategyContext,\n        uint256 oraclePrice,\n        uint256 primaryAmount, \n        uint256 secondaryAmount\n    ) internal view {\n        // Oracle price is always specified in terms of primary, so tokenIndex == 0 for primary\n        uint256 spotPrice = _getSpotPrice({\n            oracleContext: oracleContext,\n            poolContext: poolContext,\n            primaryBalance: poolContext.primaryBalance,\n            secondaryBalance: poolContext.secondaryBalance,\n            tokenIndex: 0\n        });\n\n        /// @notice Check spotPrice against oracle price to make sure that \n        /// the pool is not being manipulated\n        _checkPriceLimit(strategyContext, oraclePrice, spotPrice);\n\n        /// @notice Balancer math functions expect all amounts to be in BALANCER_PRECISION\n        uint256 primaryPrecision = 10 ** poolContext.primaryDecimals;\n        uint256 secondaryPrecision = 10 ** poolContext.secondaryDecimals;\n        primaryAmount = primaryAmount * BalancerConstants.BALANCER_PRECISION / primaryPrecision;\n        secondaryAmount = secondaryAmount * BalancerConstants.BALANCER_PRECISION / secondaryPrecision;\n\n        uint256 calculatedPairPrice = _getSpotPrice({\n            oracleContext: oracleContext,\n            poolContext: poolContext,\n            primaryBalance: primaryAmount,\n            secondaryBalance: secondaryAmount,\n            tokenIndex: 0\n        });\n```\n
MEDIUM severity: Vulnerable function: ```\n    function _revertIfLotConcluded(uint96 lotId_) internal view virtual {\n        // Beyond th. ```\n    function _revertIfLotConcluded(uint96 lotId_) internal view virtual {\n        // Beyond the conclusion time\n        if (lotData[lotId_].conclusion < uint48(block.timestamp)) {\n            revert Auction_MarketNotActive(lotId_);\n        }\n\n        // Capacity is sold-out, or cancelled\

Vulnerable code:
```\n    function _revertIfLotConcluded(uint96 lotId_) internal view virtual {\n        // Beyond the conclusion time\n        if (lotData[lotId_].conclusion < uint48(block.timestamp)) {\n            revert Auction_MarketNotActive(lotId_);\n        }\n\n        // Capacity is sold-out, or cancelled\n        if (lotData[lotId_].capacity == 0) revert Auction_MarketNotActive(lotId_);\n    }\n```\n
HIGH severity: Vulnerable function: ```\nif (!instance.transfer(getSendAddress(), forwarderBalance)) {\n    revert('. ```\nif (!instance.transfer(getSendAddress(), forwarderBalance)) {\n    revert('Could not gather ERC20');\n}\n```\n

Vulnerable code:
```\nif (!instance.transfer(getSendAddress(), forwarderBalance)) {\n    revert('Could not gather ERC20');\n}\n```\n
HIGH severity: Vulnerable function: ```\nfunction depositSwap(\n  int256 swapAmount, // (-) token1, (+) token0 for token1; amount to swa. ```\nfunction depositSwap(\n  int256 swapAmount, // (-) token1, (+) token0 for token1; amount to swap\n  uint256 deposit0,\n  uint256 deposit1,\n  address to,\n  address from,\n  bytes memory path,\n  address pos,\n  address \_router\n) external returns (uint256 shares) {\n```\n

Vulnerable code:
```\nfunction depositSwap(\n  int256 swapAmount, // (-) token1, (+) token0 for token1; amount to swap\n  uint256 deposit0,\n  uint256 deposit1,\n  address to,\n  address from,\n  bytes memory path,\n  address pos,\n  address \_router\n) external returns (uint256 shares) {\n```\n