Farseen0/scar-pairs huggingface dataset:
MEDIUM severity: Vulnerable function: ```\nFile: VaultLiquidationAction.sol\n    function _authenticateDeleverage(\n        address accoun. ```\nFile: VaultLiquidationAction.sol\n    function _authenticateDeleverage(\n        address account,\n        address vault,\n        address liquidator\n    ) private returns (\n        VaultConfig memory vaultConfig,\n        VaultAccount memory vaultAccount,\n        VaultState memory vaultStat

Vulnerable code:
```\nFile: VaultLiquidationAction.sol\n    function _authenticateDeleverage(\n        address account,\n        address vault,\n        address liquidator\n    ) private returns (\n        VaultConfig memory vaultConfig,\n        VaultAccount memory vaultAccount,\n        VaultState memory vaultState\n    ) {\n        // Do not allow invalid accounts to liquidate\n        requireValidAccount(liquidator);\n        require(liquidator != vault);\n\n        // Cannot liquidate self, if a vault needs to deleverage itself as a whole it has other methods \n        // in VaultAction to do so.\n        require(account != msg.sender);\n        require(account != liquidator);\n\n        vaultConfig = VaultConfiguration.getVaultConfigStateful(vault);\n        require(vaultConfig.getFlag(VaultConfiguration.DISABLE_DELEVERAGE) == false);\n\n        // Authorization rules for deleveraging\n        if (vaultConfig.getFlag(VaultConfiguration.ONLY_VAULT_DELEVERAGE)) {\n            require(msg.sender == vault);\n        } else {\n            require(msg.sender == liquidator);\n        }\n\n        vaultAccount = VaultAccountLib.getVaultAccount(account, vaultConfig);\n\n        // Vault accounts that are not settled must be settled first by calling settleVaultAccount\n        // before liquidation. settleVaultAccount is not permissioned so anyone may settle the account.\n        require(block.timestamp < vaultAccount.maturity, "Must Settle");\n\n        if (vaultAccount.maturity == Constants.PRIME_CASH_VAULT_MATURITY) {\n            // Returns the updated prime vault state\n            vaultState = vaultAccount.accruePrimeCashFeesToDebtInLiquidation(vaultConfig);\n        } else {\n            vaultState = VaultStateLib.getVaultState(vaultConfig, vaultAccount.maturity);\n        }\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\nbytes32 tempHash = keccak256(\n    abi.encodePacked(\n        \_url,\n     . ```\nbytes32 tempHash = keccak256(\n    abi.encodePacked(\n        \_url,\n        \_props,\n        \_timeout,\n        \_weight,\n        msg.sender\n    )\n);\n```\n

Vulnerable code:
```\nbytes32 tempHash = keccak256(\n    abi.encodePacked(\n        \_url,\n        \_props,\n        \_timeout,\n        \_weight,\n        msg.sender\n    )\n);\n```\n
HIGH severity: Vulnerable function: ```\nfunction approveDomainBid(\n    uint256 parentId,\n    string memory bidIPFSHash,\n    bytes me. ```\nfunction approveDomainBid(\n    uint256 parentId,\n    string memory bidIPFSHash,\n    bytes memory signature\n) external authorizedOwner(parentId) {\n  bytes32 hashOfSig = keccak256(abi.encode(signature));\n  approvedBids[hashOfSig] = true;\n  emit DomainBidApproved(bidIPFSHash);\n}\n```\n

Vulnerable code:
```\nfunction approveDomainBid(\n    uint256 parentId,\n    string memory bidIPFSHash,\n    bytes memory signature\n) external authorizedOwner(parentId) {\n  bytes32 hashOfSig = keccak256(abi.encode(signature));\n  approvedBids[hashOfSig] = true;\n  emit DomainBidApproved(bidIPFSHash);\n}\n```\n
MEDIUM severity: Vulnerable function: ```\n  function addToTotalRewards(uint256 _basketId) internal onlyBasketOwner(_basketId) {\n    if (. ```\n  function addToTotalRewards(uint256 _basketId) internal onlyBasketOwner(_basketId) {\n    if (baskets[_basketId].nrOfAllocatedTokens == 0) return;\n\n\n    uint256 vaultNum = baskets[_basketId].vaultNumber;\n    uint256 currentRebalancingPeriod = vaults[vaultNum].rebalancingPeriod;\n    uint25

Vulnerable code:
```\n  function addToTotalRewards(uint256 _basketId) internal onlyBasketOwner(_basketId) {\n    if (baskets[_basketId].nrOfAllocatedTokens == 0) return;\n\n\n    uint256 vaultNum = baskets[_basketId].vaultNumber;\n    uint256 currentRebalancingPeriod = vaults[vaultNum].rebalancingPeriod;\n    uint256 lastRebalancingPeriod = baskets[_basketId].lastRebalancingPeriod;\n\n\n    if (currentRebalancingPeriod <= lastRebalancingPeriod) return;\n\n\n    for (uint k = 0; k < chainIds.length; k++) {\n      uint32 chain = chainIds[k];\n      uint256 latestProtocol = latestProtocolId[chain];\n      for (uint i = 0; i < latestProtocol; i++) {\n        int256 allocation = basketAllocationInProtocol(_basketId, chain, i) / 1E18;\n        if (allocation == 0) continue;\n\n\n        int256 lastRebalanceReward = getRewardsPerLockedToken(\n          vaultNum,\n          chain,\n          lastRebalancingPeriod,\n          i\n        );\n        int256 currentReward = getRewardsPerLockedToken(\n          vaultNum,\n          chain,\n          currentRebalancingPeriod,\n          i\n        );\n        baskets[_basketId].totalUnRedeemedRewards +=\n          (currentReward - lastRebalanceReward) *\n          allocation;\n      }\n    }\n  }\n```\n
MEDIUM severity: Vulnerable function: ```\n  function transferFrom(address sender, address recipient, uint256 amount) public virtual overr. ```\n  function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\n      _transfer(sender, recipient, amount);\n      _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));\n   

Vulnerable code:
```\n  function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\n      _transfer(sender, recipient, amount);\n      _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));\n      return true;\n  }\n```\n
HIGH severity: Vulnerable function: ```\nFile: LiquidationFacetImpl.sol\n    function liquidatePartyA(address partyA, SingleUpnlSig memo. ```\nFile: LiquidationFacetImpl.sol\n    function liquidatePartyA(address partyA, SingleUpnlSig memory upnlSig) internal {\n        MAStorage.Layout storage maLayout = MAStorage.layout();\n\n        LibMuon.verifyPartyAUpnl(upnlSig, partyA);\n        int256 availableBalance = LibAccount.partyAAvaila

Vulnerable code:
```\nFile: LiquidationFacetImpl.sol\n    function liquidatePartyA(address partyA, SingleUpnlSig memory upnlSig) internal {\n        MAStorage.Layout storage maLayout = MAStorage.layout();\n\n        LibMuon.verifyPartyAUpnl(upnlSig, partyA);\n        int256 availableBalance = LibAccount.partyAAvailableBalanceForLiquidation(\n            upnlSig.upnl,\n            partyA\n        );\n        require(availableBalance < 0, "LiquidationFacet: PartyA is solvent");\n        maLayout.liquidationStatus[partyA] = true;\n        maLayout.liquidationTimestamp[partyA] = upnlSig.timestamp;\n        AccountStorage.layout().liquidators[partyA].push(msg.sender);\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\n        function checkAfterExecution(bytes32, bool) external override {\n            if (abi.de. ```\n        function checkAfterExecution(bytes32, bool) external override {\n            if (abi.decode(StorageAccessible(address(safe)).getStorageAt(uint256(GUARD_STORAGE_SLOT), 1), (address))\n                    != address(this)) \n                    {\n                revert CannotDisableThisG

Vulnerable code:
```\n        function checkAfterExecution(bytes32, bool) external override {\n            if (abi.decode(StorageAccessible(address(safe)).getStorageAt(uint256(GUARD_STORAGE_SLOT), 1), (address))\n                    != address(this)) \n                    {\n                revert CannotDisableThisGuard(address(this));\n            }\n            if (!IAvatar(address(safe)).isModuleEnabled(address(this))) {\n                    revert CannotDisableProtectedModules(address(this));\n            }\n            if (safe.getThreshold() != _correctThreshold()) {\n                     revert SignersCannotChangeThreshold();\n            }\n            // leave checked to catch underflows triggered by re-erntry\n        attempts\n            --guardEntries;\n        }\n```\n
HIGH severity: Vulnerable function: ```\nfunction test_poc() external {\n        // set token balances\n        deal(vaultTested.asset(). ```\nfunction test_poc() external {\n        // set token balances\n        deal(vaultTested.asset(), user1.addr, 20); // owner\n\n        vm.startPrank(user1.addr);\n        IERC20Metadata(vaultTested.asset()).approve(address(vaultTested), 20);\n        // owner deposits tokens when vault is open a

Vulnerable code:
```\nfunction test_poc() external {\n        // set token balances\n        deal(vaultTested.asset(), user1.addr, 20); // owner\n\n        vm.startPrank(user1.addr);\n        IERC20Metadata(vaultTested.asset()).approve(address(vaultTested), 20);\n        // owner deposits tokens when vault is open and receives vault shares\n        vaultTested.deposit(20, user1.addr);\n        // owner delegates shares balance to user\n        IERC20Metadata(address(vaultTested)).approve(\n            user2.addr,\n            vaultTested.balanceOf(user1.addr)\n        );\n        vm.stopPrank();\n\n        // vault is closed\n        vm.prank(vaultTested.owner());\n        vaultTested.close();\n\n        // epoch = 1\n        vm.startPrank(user2.addr);\n        // user requests a redeem on behlaf of owner\n        vaultTested.requestRedeem(\n            vaultTested.balanceOf(user1.addr),\n            user2.addr,\n            user1.addr,\n            ""\n        );\n        // user checks the pending redeem request amount\n        assertEq(vaultTested.pendingRedeemRequest(user2.addr), 20);\n        vm.stopPrank();\n\n        vm.startPrank(vaultTested.owner());\n        IERC20Metadata(vaultTested.asset()).approve(\n            address(vaultTested),\n            type(uint256).max\n        );\n        vaultTested.settle(23); // an epoch goes by\n        vm.stopPrank();\n\n        // epoch = 2\n\n        vm.startPrank(user2.addr);\n        // user tries to claim the redeem\n        vaultTested.claimRedeem(user2.addr);\n        assertEq(IERC20Metadata(vaultTested.asset()).balanceOf(user2.addr), 0);\n        // however, token balance of user is still empty\n        vm.stopPrank();\n\n        vm.startPrank(user1.addr);\n        // owner also tries to claim the redeem\n        vaultTested.claimRedeem(user1.addr);\n        assertEq(IERC20Metadata(vaultTested.asset()).balanceOf(user1.addr), 0);\n        // however, token balance of owner is still empty\n        vm.stopPrank();\n\n        // all the balances of owner and user are zero, indicating loss of funds\n        assertEq(vaultTested.balanceOf(user1.addr), 0);\n        assertEq(IERC20Metadata(vaultTested.asset()).balanceOf(user1.addr), 0);\n        assertEq(vaultTested.balanceOf(user2.addr), 0);\n        assertEq(IERC20Metadata(vaultTested.asset()).balanceOf(user2.addr), 0);\n    }\n```\n
HIGH severity: Vulnerable function: ```\n/* snip */\nfor (uint256 i = 0; i < instructionsLength; i++) {\n    Transce. ```\n/* snip */\nfor (uint256 i = 0; i < instructionsLength; i++) {\n    TransceiverInstruction memory instruction;\n    (instruction, offset) = parseTransceiverInstructionUnchecked(encoded, offset);\n\n    uint8 instructionIndex = instruction.index;\n\n    // The instructions passed in have to be s

Vulnerable code:
```\n/* snip */\nfor (uint256 i = 0; i < instructionsLength; i++) {\n    TransceiverInstruction memory instruction;\n    (instruction, offset) = parseTransceiverInstructionUnchecked(encoded, offset);\n\n    uint8 instructionIndex = instruction.index;\n\n    // The instructions passed in have to be strictly increasing in terms of transceiver index\n    if (i != 0 && instructionIndex <= lastIndex) {\n        revert UnorderedInstructions();\n    }\n    lastIndex = instructionIndex;\n\n    instructions[instructionIndex] = instruction;\n}\n/* snip */\n```\n
MEDIUM severity: Vulnerable function: ```\n    function claim() external {\n        address sender = msg.sender;\n\n        UserDetails st. ```\n    function claim() external {\n        address sender = msg.sender;\n\n        UserDetails storage s = userdetails[sender];\n        require(s.userDeposit != 0, "No Deposit");\n        require(s.index != vestingPoints.length, "already claimed");\n        uint256 pctAmount;\n        uint256 i 

Vulnerable code:
```\n    function claim() external {\n        address sender = msg.sender;\n\n        UserDetails storage s = userdetails[sender];\n        require(s.userDeposit != 0, "No Deposit");\n        require(s.index != vestingPoints.length, "already claimed");\n        uint256 pctAmount;\n        uint256 i = s.index;\n        for (i; i <= vestingPoints.length - 1; i++) {\n            if (block.timestamp >= vestingPoints[i][0]) {\n                pctAmount += (s.userDeposit * vestingPoints[i][1]) / 10000;\n            } else {\n                break;\n            }\n        }\n        if (pctAmount != 0) {\n            if (address(token) == address(1)) {\n                (bool sent, ) = payable(sender).call{value: pctAmount}("");  // @audit - here\n                require(sent, "Failed to send BNB to receiver");\n            } else {\n                token.safeTransfer(sender, pctAmount);\n            }\n            s.index = uint128(i);\n            s.amountClaimed += pctAmount;\n        }\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\n    function _sqrtPriceX96ToUint(uint160 sqrtPriceX96) private pure returns (uint256)\n    {\n . ```\n    function _sqrtPriceX96ToUint(uint160 sqrtPriceX96) private pure returns (uint256)\n    {\n        uint256 numerator1 = uint256(sqrtPriceX96) * \n         uint256(sqrtPriceX96);\n    return FullMath.mulDiv(numerator1, 1, 1 << 192);\n         }\n```\n

Vulnerable code:
```\n    function _sqrtPriceX96ToUint(uint160 sqrtPriceX96) private pure returns (uint256)\n    {\n        uint256 numerator1 = uint256(sqrtPriceX96) * \n         uint256(sqrtPriceX96);\n    return FullMath.mulDiv(numerator1, 1, 1 << 192);\n         }\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction setMinimumWeight(uint32 \_minimumWeight)\n    public\n    ownerOnly\n    inactive\n{\n. ```\nfunction setMinimumWeight(uint32 \_minimumWeight)\n    public\n    ownerOnly\n    inactive\n{\n    //require(\_minimumWeight > 0, "Min weight 0");\n    //\_validReserveWeight(\_minimumWeight);\n    minimumWeight = \_minimumWeight;\n    emit MinimumWeightUpdated(\_minimumWeight);\n}\n```\n

Vulnerable code:
```\nfunction setMinimumWeight(uint32 \_minimumWeight)\n    public\n    ownerOnly\n    inactive\n{\n    //require(\_minimumWeight > 0, "Min weight 0");\n    //\_validReserveWeight(\_minimumWeight);\n    minimumWeight = \_minimumWeight;\n    emit MinimumWeightUpdated(\_minimumWeight);\n}\n```\n
MEDIUM severity: Vulnerable function: ```\n    for (uint256 i = 0; i < tokenList.length; i++) {\n        address _toke. ```\n    for (uint256 i = 0; i < tokenList.length; i++) {\n        address _token = tokenList[i];\n        (address assetDToken,,,,,,,,,,) = d3Vault.getAssetInfo(_token);\n        uint256 tokenBalance = IERC20(assetDToken).balanceOf(user);\n        if (tokenBalance > 0) {\n            tokenBalance =

Vulnerable code:
```\n    for (uint256 i = 0; i < tokenList.length; i++) {\n        address _token = tokenList[i];\n        (address assetDToken,,,,,,,,,,) = d3Vault.getAssetInfo(_token);\n        uint256 tokenBalance = IERC20(assetDToken).balanceOf(user);\n        if (tokenBalance > 0) {\n            tokenBalance = tokenBalance.mul(d3Vault.getExchangeRate(token)); <- @audit-issue queries token instead of _token\n            (uint256 tokenPrice, uint8 priceDecimal) = ID3Oracle(d3Vault._ORACLE_()).getOriginalPrice(_token);\n            usedQuota = usedQuota + tokenBalance * tokenPrice / 10 ** (priceDecimal+tokenDecimals);\n        }\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\n    function handleBadDebt(Types.State storage state, address liquidatedTrader)\n        extern. ```\n    function handleBadDebt(Types.State storage state, address liquidatedTrader)\n        external\n    {\n        if (\n            state.openPositions[liquidatedTrader].length == 0 &&\n            !Liquidation._isSafe(state, liquidatedTrader)\n        ) {\n            int256 primaryCredit = st

Vulnerable code:
```\n    function handleBadDebt(Types.State storage state, address liquidatedTrader)\n        external\n    {\n        if (\n            state.openPositions[liquidatedTrader].length == 0 &&\n            !Liquidation._isSafe(state, liquidatedTrader)\n        ) {\n            int256 primaryCredit = state.primaryCredit[liquidatedTrader];\n            uint256 secondaryCredit = state.secondaryCredit[liquidatedTrader];\n            state.primaryCredit[state.insurance] += primaryCredit;\n            state.secondaryCredit[state.insurance] += secondaryCredit;\n            state.primaryCredit[liquidatedTrader] = 0;\n            state.secondaryCredit[liquidatedTrader] = 0;\n            emit HandleBadDebt(\n                liquidatedTrader,\n                primaryCredit,\n                secondaryCredit\n            );\n        }\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\n    uint256 intermediate = inWei.div(10**(token1.decimals() -\n         tok. ```\n    uint256 intermediate = inWei.div(10**(token1.decimals() -\n         token0.decimals()));\n```\n

Vulnerable code:
```\n    uint256 intermediate = inWei.div(10**(token1.decimals() -\n         token0.decimals()));\n```\n
HIGH severity: Vulnerable function: ```\nfunction canRemoveLiquidity(address target, bytes calldata data)\n    internal\n    view\n    r. ```\nfunction canRemoveLiquidity(address target, bytes calldata data)\n    internal\n    view\n    returns (bool, address[] memory, address[] memory)\n{\n    (,uint256[2] memory amounts) = abi.decode(\n        data[4:],\n        (uint256, uint256[2])\n    );\n\n    address[] memory tokensOut = new a

Vulnerable code:
```\nfunction canRemoveLiquidity(address target, bytes calldata data)\n    internal\n    view\n    returns (bool, address[] memory, address[] memory)\n{\n    (,uint256[2] memory amounts) = abi.decode(\n        data[4:],\n        (uint256, uint256[2])\n    );\n\n    address[] memory tokensOut = new address[](1);\n    tokensOut[0] = target;\n\n    uint i; uint j;\n    address[] memory tokensIn = new address[](2);\n    while(i < 2) {\n        if(amounts[i] > 0)\n            tokensIn[j++] = IStableSwapPool(target).coins(i);\n        unchecked { ++i; }\n    }\n    assembly { mstore(tokensIn, j) }\n\n    return (true, tokensIn, tokensOut);\n}\n```\n
MEDIUM severity: Vulnerable function: ```\n    function claimBids(uint96 lotId_, uint64[] calldata bidIds_) external override nonReentrant. ```\n    function claimBids(uint96 lotId_, uint64[] calldata bidIds_) external override nonReentrant {\n        \n        // rest of code.\n\n        for (uint256 i = 0; i < bidClaimsLen; i++) {\n            Auction.BidClaim memory bidClaim = bidClaims[i];\n\n            if (bidClaim.payout > 0) {\n

Vulnerable code:
```\n    function claimBids(uint96 lotId_, uint64[] calldata bidIds_) external override nonReentrant {\n        \n        // rest of code.\n\n        for (uint256 i = 0; i < bidClaimsLen; i++) {\n            Auction.BidClaim memory bidClaim = bidClaims[i];\n\n            if (bidClaim.payout > 0) {\n               \n=>              _allocateQuoteFees(\n                    protocolFee,\n                    referrerFee,\n                    bidClaim.referrer,\n                    routing.seller,\n                    routing.quoteToken,\n=>                  bidClaim.paid\n                );\n```\n
HIGH severity: Vulnerable function: ```\nfunction createTier(\n        mapping(uint256 => ITokenSaleProposal.Tier) storage tiers,\n     . ```\nfunction createTier(\n        mapping(uint256 => ITokenSaleProposal.Tier) storage tiers,\n        uint256 newTierId,\n        ITokenSaleProposal.TierInitParams memory _tierInitParams\n    ) external {\n\n       // rest of code.\n         /// @dev return value is not checked intentionally\n  >  

Vulnerable code:
```\nfunction createTier(\n        mapping(uint256 => ITokenSaleProposal.Tier) storage tiers,\n        uint256 newTierId,\n        ITokenSaleProposal.TierInitParams memory _tierInitParams\n    ) external {\n\n       // rest of code.\n         /// @dev return value is not checked intentionally\n  >      tierInitParams.saleTokenAddress.call(\n            abi.encodeWithSelector(\n                IERC20.transferFrom.selector,\n                msg.sender,\n                address(this),\n                totalTokenProvided\n            )\n        );  //@audit -> no check if the contract balance has increased proportional to the totalTokenProvided\n   }\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction _updateVirtualPrice(uint256 _currentBlockTime, address _collateralAddress) internal { . ```\nfunction _updateVirtualPrice(uint256 _currentBlockTime, address _collateralAddress) internal { \n    (   ,\n        ,\n        ,\n        uint256 interestPer3Min,\n        uint256 lastUpdateTime,\n        uint256 virtualPrice,\n\n    ) = _getCollateral(_collateralAddress);\n    uint256 timeDelt

Vulnerable code:
```\nfunction _updateVirtualPrice(uint256 _currentBlockTime, address _collateralAddress) internal { \n    (   ,\n        ,\n        ,\n        uint256 interestPer3Min,\n        uint256 lastUpdateTime,\n        uint256 virtualPrice,\n\n    ) = _getCollateral(_collateralAddress);\n    uint256 timeDelta = _currentBlockTime - lastUpdateTime;\n    //exit gracefully if two users call the function for the same collateral in the same 3min period\n    //@audit increments \n    uint256 threeMinuteDelta = timeDelta / 180; \n    if(threeMinuteDelta > 0) {\n        for (uint256 i = 0; i < threeMinuteDelta; i++ ){\n        virtualPrice = (virtualPrice * interestPer3Min) / LOAN_SCALE; \n        }\n        collateralBook.vaultUpdateVirtualPriceAndTime(_collateralAddress, virtualPrice, _currentBlockTime);\n    }\n}\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction init(IWeightedPool \_pool) external {\n    require(address(pool) == address(0), "Balan. ```\nfunction init(IWeightedPool \_pool) external {\n    require(address(pool) == address(0), "BalancerLBPSwapper: initialized");\n\n    pool = \_pool;\n    IVault \_vault = \_pool.getVault();\n\n    vault = \_vault;\n\n    // Check ownership\n    require(\_pool.getOwner() == address(this), "Balance

Vulnerable code:
```\nfunction init(IWeightedPool \_pool) external {\n    require(address(pool) == address(0), "BalancerLBPSwapper: initialized");\n\n    pool = \_pool;\n    IVault \_vault = \_pool.getVault();\n\n    vault = \_vault;\n\n    // Check ownership\n    require(\_pool.getOwner() == address(this), "BalancerLBPSwapper: contract not pool owner");\n```\n
MEDIUM severity: Vulnerable function: ```\nFeeData.sol\n    function setFeeValue(uint256 feeValue) external onlyOwner {\n        require(f. ```\nFeeData.sol\n    function setFeeValue(uint256 feeValue) external onlyOwner {\n        require(feeValue < _feeDenominator, "Fee percentage must be less than 1");\n        _feeValue = feeValue;\n    }\n\n    function setFixedFee(uint256 fixedFee) external onlyOwner {//@audit-issue validate min/ma

Vulnerable code:
```\nFeeData.sol\n    function setFeeValue(uint256 feeValue) external onlyOwner {\n        require(feeValue < _feeDenominator, "Fee percentage must be less than 1");\n        _feeValue = feeValue;\n    }\n\n    function setFixedFee(uint256 fixedFee) external onlyOwner {//@audit-issue validate min/max\n        _fixedFee = fixedFee;\n    }\n```\n