Farseen0/scar-pairs huggingface dataset:
MEDIUM severity: This vulnerability is related to incorrect parameters being passed to functions and integrations, le. This vulnerability is related to incorrect parameters being passed to functions and integrations, leading to potential errors and unexpected behavior. Specifically, the code is attempting to approve a non-existent token, which is not the intended behavior.\n\nIn the first instance, the code is tryin...

Vulnerable code:
```\nelse if (p == uint8(Principals.Notional)) {\n    ILender(lender).approve(address(0), address(0), address(0), a);\n```\n```\nelse if (p == uint8(Principals.Notional)) {\n    if (a!= address(0)) {\n        Safe.approve(IERC20(address(0)), a, type(uint256).max);\n    }\n```\n```\nif (address(this).balance < r) {\n    revert Exception(11, address(this).balance, r, address(0), address(0));\n}\n\n// Calculate the amount of Tempus principal tokens received after the deposit\nuint256 received = IERC20(principal).balanceOf(address(this)) - start;\n\n// Swap on the Tempus Router using the provided market and params\nITempus(controller).depositAndFix(x, lent, true, r, d);\n```\n```\nfunction depositAndFix(\n    ITempusAMM tempusAMM,\n    uint256 tokenAmount,\n    bool isBackingToken,\n    uint256 minTYSRate,\n    uint256 deadline\n) external payable nonReentrant {\n    uint256 minReturn = swapAmount.mulFV(minTYSRate, targetPool.backingTokenONE());\n```
MEDIUM severity: The `exchangeRateStored()` function in the `uToken` contract allows an attacker to perform a front-r. The `exchangeRateStored()` function in the `uToken` contract allows an attacker to perform a front-running attack on repayments. This vulnerability arises from the fact that `_repayBorrowFresh()` increases the `totalRedeemable` value, which affects the final exchange rate calculation used in functio...

Vulnerable code:
```\nfunction increaseTotalSupply(uint256 _amount) private {\n    daiMock.mint(address(this), _amount);\n    daiMock.approve(address(uToken), _amount);\n    uToken.mint(_amount);\n}\n\nfunction 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(" [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(" [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(" [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```\n[PASS] testMintRedeemSandwich() (gas: 560119)\n\nLogs:\n\n    [UToken] Total supply: 150000000000000000000\n    [UToken] BOB balance: 100000000000000000000\n    [DAI]    BOB balance: 0\n    [1] Exchange rate: 1000000000000000000\n\n    [UToken] Total supply: 150000000000000000000\n    [UToken] ALICE balance: 0\n    [DAI]    ALICE balance: 99474750000000000000\n    [2] Exchange rate: 1000084166666666666\n\n    [UToken] Total supply: 50000000000000000000\n    [UToken] BOB balance: 0\n    [DAI]    BOB balance: 100008416666666666600\n    [3] Exchange rate: 1000084166666666668\n```
MEDIUM severity: The rebalancing process, triggered in response to a peg-down event, attempts to sell collateral to m. The rebalancing process, triggered in response to a peg-down event, attempts to sell collateral to maintain a stable asset ratio. However, the calculation for determining the amount of collateral to sell can underflow, leading to potential reverts.\n\nDuring the rebalancing process, the `rebalance()...

Vulnerable code:
```\nuint256 collateralval = IERC20Upgradeable(collateral[i].token).balanceOf(USSD) * 1e18 / (10**IERC20MetadataUpgradeable(collateral[i].token).decimals()) * collateral[i].oracle.getPriceUSD() / 1e18;\n\nif (collateralval > amountToBuyLeftUSD) {\n    // sell a portion of collateral and exit\n    if (collateral[i].pathSell.length > 0) {\n        uint256 amountBefore = IERC20Upgradeable(baseAsset).balanceOf(USSD);\n        uint256 amountToSellUnits = IERC20Upgradeable(collateral[i].token).balanceOf(USSD) * ((amountToBuyLeftUSD * 1e18 / collateralval) / 1e18) / 1e18;\n        IUSSD(USSD).uniV3SwapInput(collateral[i].pathSell, amountToSellUnits);\n        amountToBuyLeftUSD -= (IERC20Upgradeable(baseAsset).balanceOf(USSD) - amountBefore);\n        DAItosell += (IERC20Upgradeable(baseAsset).balanceOf(USSD) - amountBefore);\n    } else {\n```\n```\nif (collateralval >= amountToBuyLeftUSD / 20) {\n    uint256 amountBefore = IERC20Upgradeable(baseAsset).balanceOf(USSD);\n    // sell all collateral and move to next one\n    IUSSD(USSD).UniV3SwapInput(collateral[i].pathSell, IERC20Upgradeable(collateral[i].token).balanceOf(USSD));\n    amountToBuyLeftUSD -= (IERC20Upgradeable(baseAsset).balanceOf(USSD) - amountBefore);\n    DAItosell += (IERC20Upgradeable(baseAsset).balanceOf(USSD) - amountBefore);\n}\n```
MEDIUM severity: The `createUniswapRangeOrder()` function in the smart contract is vulnerable to a potential issue wh. The `createUniswapRangeOrder()` function in the smart contract is vulnerable to a potential issue where it charges the manager's funds instead of the pool's funds. This occurs when the function is called from the manager flow or pool-induced from `hedgeDelta()`. \n\nThe function assumes that the sen...

Vulnerable code:
```\nif (inversed && balance < amountDesired) {\n    uint256 transferAmount = amountDesired - balance;\n    uint256 parentPoolBalance = ILiquidityPool(parentLiquidityPool).getBalance(address(token0));\n    if (parentPoolBalance < transferAmount) {\n        revert CustomErrors.WithdrawExceedsLiquidity();\n    }\n    SafeTransferLib.safeTransferFrom(address(token0), msg.sender, address(this), transferAmount);\n}\n```\n```\nfunction createUniswapRangeOrder(\n    RangeOrderParams calldata params,\n    uint256 amountDesired\n) external {\n    require(!_inActivePosition(), "RangeOrder: active position");\n    _onlyManager();\n\n    bool inversed = collateralAsset == address(token0);\n    _createUniswapRangeOrder(params, amountDesired, inversed);\n}\n```
MEDIUM severity: The `_buy` function of the `EternalHeroesFactory` contract is vulnerable to a re-entrancy attack, wh. The `_buy` function of the `EternalHeroesFactory` contract is vulnerable to a re-entrancy attack, which allows an attacker to manipulate the price of Eternal Heroes. This vulnerability arises from the fact that the contract does not properly handle the refund process before minting tokens to the rec...

Vulnerable code:
```\nuint256 refundAmount = _arcAmount.sub(total_cost);\nif (refundAmount > 0) {\n    arcadeumCoin.safeTransferFrom(address(this), _recipient, arcadeumCoinID, refundAmount, "");\n}\n\nfactoryManager.batchMint(_recipient, _ids, amounts_to_mint, "");\n```
MEDIUM severity: This vulnerability occurs when the `ShortLongSpell.openPosition()` function passes an incorrect addr. This vulnerability occurs when the `ShortLongSpell.openPosition()` function passes an incorrect address to the `_doPutCollateral()` function. Specifically, the `balanceOf()` method is called with the address of the current contract (`address(this)`) instead of the address of the vault (`address(vaul...

Vulnerable code:
```\naddress vault = strategies[param.strategyId].vault;\n_doPutCollateral(\n    vault,\n    IERC20Upgradeable(ISoftVault(vault).uToken()).balanceOf(address(this))\n);\n```
MEDIUM severity: The internal accounting of the vault balance for a given bAsset may diverge from the actual token ba. The internal accounting of the vault balance for a given bAsset may diverge from the actual token balance in the lending pool, violating a fundamental correctness property. This discrepancy can occur due to the way the lending pool integration, specifically Compound, updates the vault balance.\n\nTh...

Vulnerable code:
```\nquantityDeposited = _amount;\n\nif (_isTokenFeeCharged) {\n    uint256 prevBal = _checkBalance(cToken);\n    require(cToken.mint(_amount) == 0, "cToken mint failed");\n    uint256 newBal = _checkBalance(cToken);\n    quantityDeposited = _min(quantityDeposited, newBal.sub(prevBal));\n} else {\n    require(cToken.mint(_amount) == 0, "cToken mint failed");\n}\n\nemit Deposit(_bAsset, address(cToken), quantityDeposited);\n```\n```\nbasketManager.increaseVaultBalance(\n    bInfo.index,\n    integrator,\n    quantityDeposited\n)\n```\n```\nuint256 deposited = IPlatformIntegration(_integrator).deposit(_bAsset, quantityTransferred, _erc20TransferFeeCharged);\n```\n```\nuint256 balance = IPlatformIntegration(integrations[i]).checkBalance(b.addr);\nuint256 oldVaultBalance = b.vaultBalance;\n\nif (balance > oldVaultBalance && b.status == BassetStatus.Normal) {\n    // Update balance\n    basket.bassets[i].vaultBalance = balance;\n}\n```
MEDIUM severity: The Postman's message delivery service allows for cross-chain message transmission, where users can . The Postman's message delivery service allows for cross-chain message transmission, where users can specify parameters such as the sender, receiver, fee, value, message number, and calldata. The Postman estimates the gas required for message delivery on the destination chain, ensuring that the fees...

Vulnerable code:
```\n(bool success, bytes memory returnData) = _to.call{ value: _value }(_calldata);\nif (!success) {\n    if (returnData.length > 0) {\n        assembly {\n            let data_size := mload(returnData)\n            revert(add(32, returnData), data_size)\n        }\n    } else {\n        revert MessageSendingFailed(_to);\n    }\n}\n```\n```\n(bool success, bytes memory returnData) = _to.call{ value: _value }(_calldata);\nif (!success) {\n    if (returnData.length > 0) {\n        assembly {\n            let data_size := mload(returnData)\n            revert(add(32, returnData), data_size)\n        }\n    } else {\n        revert MessageSendingFailed(_to);\n    }\n}\n```
MEDIUM severity: The `_decrementGaugeWeight` function in the ERC20Gauges contract has an edge case scenario where a u. The `_decrementGaugeWeight` function in the ERC20Gauges contract has an edge case scenario where a user can attempt to decrement a gauge that is not in their gauge list by 0 weight. This is possible because the function does not explicitly check if the gauge belongs to the user before processing the...

Vulnerable code:
```\nfunction _decrementGaugeWeight(\n    address user,\n    address gauge,\n    uint112 weight,\n    uint32 cycle\n) internal {\n    uint112 oldWeight = getUserGaugeWeight[user][gauge];\n\n    getUserGaugeWeight[user][gauge] = oldWeight - weight;\n    if (oldWeight == weight) {\n        assert(userGauges[user].remove(gauge));\n    }\n```\n```\nuint112 oldWeight = getUserGaugeWeight[user][gauge];\n\ngetUserGaugeWeight[user][gauge] = oldWeight - weight;\n```\n```\nassert(_userGauges[user].remove(gauge))\n```
MEDIUM severity: The `deposit` function in the provided smart contract allows for re-entrancy attacks when interactin. The `deposit` function in the provided smart contract allows for re-entrancy attacks when interacting with ERC-777 tokens. Specifically, the `transferFrom` call at the end of the `deposit` function creates a window of opportunity for an attacker to re-enter the `deposit` function before the tokens a...

Vulnerable code:
```\nfunction deposit(\n    address asset,\n    uint256 amount,\n    address onBehalfOf,\n    uint16 referralCode\n) external override {\n    _whenNotPaused();\n    ReserveLogic.ReserveData storage reserve = _reserves[asset];\n\n    ValidationLogic.validateDeposit(reserve, amount);\n\n    address aToken = reserve.aTokenAddress;\n\n    reserve.updateState();\n    reserve.updateInterestRates(asset, aToken, amount, 0);\n\n    bool isFirstDeposit = IAToken(aToken).balanceOf(onBehalfOf) == 0;\n    if (isFirstDeposit) {\n        _usersConfig[onBehalfOf].setUsingAsCollateral(reserve.id, true);\n    }\n\n    IAToken(aToken).mint(onBehalfOf, amount, reserve.liquidityIndex);\n\n    // transfer to the aToken contract\n    IERC20(asset).safeTransferFrom(msg.sender, aToken, amount);\n\n    emit Deposit(asset, msg.sender, onBehalfOf, amount, referralCode);\n}\n```
MEDIUM severity: The `price` variable at Line 137 is denominated in 18 decimals, as the `getPriceInEth` function cons. The `price` variable at Line 137 is denominated in 18 decimals, as the `getPriceInEth` function consistently returns the `price` in 18 decimal precision. However, there is no need to scale the accumulated `price` by 1e18. This unnecessary scaling causes the average `price` (`existing._initAcc`) to b...

Vulnerable code:
```\naveragePrice = existing._initAcc * 1e18 / INIT_SAMPLE_COUNT\naveragePrice = 36e18 * 1e18 / 18\naveragePrice = 36e36 / 18\naveragePrice = 2e36\n```\n```\nexisting.slowFilterPrice = Stats.getFilteredValue(SLOW_ALPHA, existing.slowFilterPrice, price)\nexisting.fastFilterPrice = Stats.getFilteredValue(FAST_ALPHA, existing.fastFilterPrice, price)\n\nexisting.slowFilterPrice = Stats.getFilteredValue(SLOW_ALPHA, 2e36, 3e18)\nexisting.fastFilterPrice = Stats.getFilteredValue(FAST_ALPHA, 2e36, 3e18)\n```\n```\n((priorValue * (1e18 - alpha) + currentValue * alpha) / 1e18)\n((priorValue * (1e18 - 33e16) + currentValue * 33e16) / 1e18)\n((priorValue * 67e16) + (currentValue * 33e16)) / 1e18\n((2e36 * 67e16) + (3e18 * 33e16)) / 1e18\n1.34e36\n```\n```\nFile: IncentivePricingStats.sol\n\nfunction updatePricingInfo(IRootPriceOracle pricer, address token) internal {\n    uint256 price = pricer.getPriceInEth(token);\n\n    uint256 timestamp = block.timestamp;\n    existing.lastSnapshot = uint40(timestamp);\n\n    if (existing._initComplete) {\n        existing.slowFilterPrice = Stats.getFilteredValue(SLOW_ALPHA, existing.slowFilterPrice, price);\n        existing.fastFilterPrice = Stats.getFilteredValue(FAST_ALPHA, existing.fastFilterPrice, price);\n    } else {\n        existing._initCount += 1;\n        existing._initAcc += price;\n\n        if (existing._initCount == INIT_SAMPLE_COUNT) {\n            existing._initComplete = true;\n            uint256 averagePrice = existing._initAcc * 1e18 / INIT_SAMPLE_COUNT;\n            existing.fastFilterPrice = averagePrice;\n            existing.slowFilterPrice = averagePrice;\n        }\n    }\n```
MEDIUM severity: The vulnerability lies in the implementation of DepositReceipt_ETH and DepositReciept_USDC, which ut. The vulnerability lies in the implementation of DepositReceipt_ETH and DepositReciept_USDC, which utilize a swap router to check the value of liquidity by swapping 100 tokens. This approach is problematic for high-value tokens like WBTC, as the massive value of swapping 100 WBTC tokens would likely...

Vulnerable code:
```\nuint256 amountOut; // amount received by trade\nbool stablePool; // if the traded pool is stable or volatile\n\n(amountOut, stablePool) = router.getAmountOut(HUNDRED_TOKENS, token1, USDC);\n```\n```\nfunction _priceCollateral(IDepositReceipt depositReceipt, uint256 _NFTId) internal view returns (uint256) {\n    uint256 pooledTokens = depositReceipt.pooledTokens(_NFTId);\n    return depositReceipt.priceLiquidity(pooledTokens);\n}\n\nfunction totalCollateralValue(address _collateralAddress, address _owner) public view returns (uint256) {\n    NFTids memory userNFTs = loanNFTids[_collateralAddress][_owner];\n    IDepositReceipt depositReceipt = IDepositReceipt(_collateralAddress);\n    uint256 totalPooledTokens;\n    for (uint256 i = 0; i < NFT_LIMIT; i++) {\n        if (userNFTs.ids[i]!= 0) {\n            totalPooledTokens += depositReceipt.pooledTokens(userNFTs.ids[i]);\n        }\n    }\n    return depositReceipt.priceLiquidity(totalPooledTokens);\n}\n```
MEDIUM severity: The `_endingDelegations` list is a redundant data structure that is created for optimization purpose. The `_endingDelegations` list is a redundant data structure that is created for optimization purposes, but its usage is limited to the `getPurchasedAmount` function. This function iterates over the `_endingDelegations` list for a specific holder, checking if any delegation has been ended, and then r...

Vulnerable code:
```\nfunction getPurchasedAmount(address holder) public returns (uint amount) {\n    for (uint i = 0; i < _endingDelegations[holder].length; ++i) {\n        getState(_endingDelegations[holder][i]);\n    }\n    return _purchased[holder];\n```
MEDIUM severity: This vulnerability is related to the potential for gas savings by terminating early in a function in. This vulnerability is related to the potential for gas savings by terminating early in a function invocation that is bound to revert. In the `ForgeValidator.validateRedemption` function, there is an opportunity to terminate the execution earlier than necessary, which could result in unnecessary gas...

Vulnerable code:
```\nif (atLeastOneBecameOverweight) {\n    return (false, "bAssets must remain below max weight", false);\n}\n```
MEDIUM severity: The `LSTCalculatorBase.sol` contract's deployment process is vulnerable to a slashing event's impact. The `LSTCalculatorBase.sol` contract's deployment process is vulnerable to a slashing event's impact on the initial APR calculation. The contract's `calculateAnnualizedChangeMinZero` function, which is used to calculate the APR between the deployment and the first snapshot taken after `APR_FILTER_IN...

Vulnerable code:
```\nreturn ((priorValue * (1e18 - alpha)) + (currentValue * alpha)) / 1e18\n```
MEDIUM severity: The DynamicLiquidTokenConverter input validation vulnerability in the `setMinimumWeight` and `setSte. The DynamicLiquidTokenConverter input validation vulnerability in the `setMinimumWeight` and `setStepWeight` functions allows an attacker to manipulate the system settings by setting out-of-bounds values for `stepWeight` or `setMinimumWeight`. This can lead to functionality not working correctly, sp...

Vulnerable code:
```\nfunction setMinimumWeight(uint32 _minimumWeight)\n    public\n    ownerOnly\n    inactive\n{\n    minimumWeight = _minimumWeight;\n    emit MinimumWeightUpdated(_minimumWeight);\n}\n```\n```\nfunction setStepWeight(uint32 _stepWeight)\n    public\n    ownerOnly\n    inactive\n{\n    stepWeight = _stepWeight;\n    emit StepWeightUpdated(_stepWeight);\n}\n```
MEDIUM severity: The vulnerability lies in the improper distribution of entrance fees in loans with multiple lenders.. The vulnerability lies in the improper distribution of entrance fees in loans with multiple lenders. Specifically, when a borrower takes out multiple loans, the entrance fees are not credited to each lender individually, but rather are distributed among all lenders. This can result in some lenders l...

Vulnerable code:
```\nborrowing.feesOwed += entranceFee;\n```\n```\nuint256 feesAmt = FullMath.mulDiv(feesOwed, cache.holdTokenDebt, borrowedAmount);\nloansFeesInfo[creditor][cache.holdToken] += feesAmt;\nharvestedAmt += feesAmt;\n```
MEDIUM severity: The vulnerability allows an attacker to steal rewards accumulated by other users by manipulating the. The vulnerability allows an attacker to steal rewards accumulated by other users by manipulating the depositors. This is achieved by minting a new NFT on their own depositor and then withdrawing it from another user's depositor, effectively transferring the rewards to their own depositor. This can b...

Vulnerable code:
```\nfunction withdrawFromGauge(uint256 _NFTId, address[] memory _tokens) public {\n    uint256 amount = depositReceipt.pooledTokens(_NFTId);\n    depositReceipt.burn(_NFTId);\n    gauge.getReward(address(this), _tokens);\n    gauge.withdraw(amount);\n    AMMToken.transfer(msg.sender, amount);\n}\n```
MEDIUM severity: This vulnerability occurs when the calculation of `shares` involves a division operation before mult. This vulnerability occurs when the calculation of `shares` involves a division operation before multiplication, which can lead to a loss of precision and accuracy in the distribution of `dittoMatchedShares` to users. Specifically, the `timeTillMatch` value is divided by a constant `1 day` before bei...

Vulnerable code:
```\nuint88 shares = eth * (timeTillMatch / 1) / days;\n```
MEDIUM severity: This vulnerability occurs when a validator fails to meet the Minimum Staking Requirement (MSR), whic. This vulnerability occurs when a validator fails to meet the Minimum Staking Requirement (MSR), which is a critical condition that prevents token holders from switching to a different validator. This situation can arise when a validator does not have sufficient funds to operate a node, thereby rende...

Vulnerable code:
```\nrequire((validatorNodes.length + 1) * msr <= delegationsTotal, "Validator has to meet Minimum Staking Requirement");\n```
MEDIUM severity: The vulnerability arises from the accumulation of rounding errors in the slashing process, which can. The vulnerability arises from the accumulation of rounding errors in the slashing process, which can lead to inconsistencies in the calculation of various values. Specifically, when slashing occurs, the `_delegatedToValidator` and `_effectiveDelegatedToValidator` values are reduced, but the calculat...

Vulnerable code:
```\nfunction confiscate(uint validatorId, uint amount) external {\n    uint currentMonth = getCurrentMonth();\n    Fraction memory coefficient = reduce(_delegatedToValidator[validatorId], amount, currentMonth);\n    reduce(_effectiveDelegatedToValidator[validatorId], coefficient, currentMonth);\n    putToSlashingLog(_slashesOfValidator[validatorId], coefficient, currentMonth);\n    _slashes.push(SlashingEvent({reducingCoefficient: coefficient, validatorId: validatorId, month: currentMonth}));\n}\n```\n```\nif (oldValue > 0):\n    reduce(\n        _delegatedByHolderToValidator[holder][validatorId],\n        _delegatedByHolder[holder],\n        _slashes[index].reducingCoefficient,\n        month\n    )\n    reduce(\n        _effectiveDelegatedByHolderToValidator[holder][validatorId],\n        _slashes[index].reducingCoefficient,\n        month\n    )\n    slashingSignals[index.sub(begin)].holder = holder\n    slashingSignals[index.sub(begin)].penalty = oldValue.sub(getAndUpdateDelegatedByHolderToValidator(holder, validatorId, month))\n```\n```\nuint amountAfterSlashing = calculateDelegationAmountAfterSlashing(delegationId);\n```
MEDIUM severity: The protocol's `Swap` library contains a hardcoded address for WETH (Wrapped Ether), which is a toke. The protocol's `Swap` library contains a hardcoded address for WETH (Wrapped Ether), which is a token on the Ethereum blockchain. This hardcoded address is set to `0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2`. While the protocol's README.md mentions support for multiple EVM-based blockchains, includi...

Vulnerable code:
```\naddress internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;\n```