function
stringlengths 12
63.3k
| severity
stringclasses 4
values |
|---|---|
```\nfunction _mintGenesisNFT() internal {\n _tokenIds++;\n\n emit GenesisNFTMinted(_tokenIds, msg.sender);\n\n _mint(msg.sender, _tokenIds, 1, "");\n}\n```\n | none |
```\nfunction _approve(address owner, address spender, uint256 amount) private {\n require(owner != address(0), "ERC20: approve from the zero address");\n require(spender != address(0), "ERC20: approve to the zero address");\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n}\n```\n | none |
```\nfunction approveBorrow(address spender, uint256 amount) external returns (bool) {\n _approveBorrow(msg.sender, spender, amount);\n return true;\n }\n```\n | high |
```\nfunction div(\n uint256 a,\n uint256 b,\n string memory errorMessage\n) internal pure returns (uint256) {\n unchecked {\n require(b > 0, errorMessage);\n return a / b;\n }\n}\n```\n | none |
```\nfunction get(Map storage map, address key) internal view returns (uint256) {\n return map.values[key];\n}\n```\n | none |
```\n (uint256 unitFee, , ) = _fees(10**decimals(), settlementFeePercentage);\n amount = (newFee * 10**decimals()) / unitFee;\n```\n | medium |
```\nfunction unlock(\n uint128 lockId,\n address recipient, uint256 amount,\n bytes4 lockSource, bytes4 tokenSource,\n bytes32 tokenSourceAddress,\n bytes calldata signature) external isActive {\n // Create message hash and validate the signature\n IValidator(validator).createUnlock(\n lockId,\n recipient,\n amount,\n lockSource,\n tokenSource,\n tokenSourceAddress,\n signature);\n\n // Mark lock as received\n address tokenAddress = tokenSourceMap[tokenSource][tokenSourceAddress];\n require(tokenAddress != address(0), "Bridge: unsupported token");\n TokenInfo memory tokenInfo = tokenInfos[tokenAddress];\n\n // Transform amount form system to token precision\n uint256 amountWithTokenPrecision = fromSystemPrecision(amount, tokenInfo.precision);\n uint256 fee = 0;\n if (msg.sender == unlockSigner) {\n fee = FeeOracle(feeOracle).minFee(tokenAddress);\n require(amountWithTokenPrecision > fee, "Bridge: amount too small");\n amountWithTokenPrecision = amountWithTokenPrecision - fee;\n }\n\n if (tokenInfo.tokenType == TokenType.Base) {\n // If token is WETH - transfer ETH\n payable(recipient).transfer(amountWithTokenPrecision);\n if (fee > 0) {\n payable(feeCollector).transfer(fee);\n }\n } else if (tokenInfo.tokenType == TokenType.Native) {\n // If token is native - transfer the token\n IERC20(tokenAddress).safeTransfer(recipient, amountWithTokenPrecision);\n if (fee > 0) {\n IERC20(tokenAddress).safeTransfer(feeCollector, fee);\n }\n } else if (tokenInfo.tokenType == TokenType.Wrapped) {\n // Else token is wrapped - mint tokens to the user\n WrappedToken(tokenAddress).mint(recipient, amountWithTokenPrecision);\n if (fee > 0) {\n WrappedToken(tokenAddress).mint(feeCollector, fee);\n }\n } else if (tokenInfo.tokenType == TokenType.WrappedV0) {\n // Legacy wrapped token\n IWrappedTokenV0(tokenAddress).mint(recipient, amountWithTokenPrecision);\n if (fee > 0) {\n IWrappedTokenV0(tokenAddress).mint(feeCollector, fee);\n }\n }\n\n emit Received(recipient, tokenAddress, amountWithTokenPrecision, lockId, lockSource);\n}\n```\n | none |
```\n function buyCollateral(address from, uint256 borrowAmount, uint256 supplyAmount, bytes calldata data)\n external\n optionNotPaused(PauseType.LeverageBuy)\n solvent(from, false)\n notSelf(from)\n returns (uint256 amountOut)\n {\n if (address(leverageExecutor) == address(0)) {\n revert LeverageExecutorNotValid();\n }\n\n // Stack too deep fix\n _BuyCollateralCalldata memory calldata_;\n _BuyCollateralMemoryData memory memoryData;\n {\n calldata_.from = from;\n calldata_.borrowAmount = borrowAmount;\n calldata_.supplyAmount = supplyAmount;\n calldata_.data = data;\n }\n\n {\n uint256 supplyShare = yieldBox.toShare(assetId, calldata_.supplyAmount, true);\n if (supplyShare > 0) {\n (memoryData.supplyShareToAmount,) =\n yieldBox.withdraw(assetId, calldata_.from, address(leverageExecutor), 0, supplyShare);\n }\n }\n\n {\n (, uint256 borrowShare) = _borrow(\n calldata_.from,\n address(this),\n calldata_.borrowAmount,\n _computeVariableOpeningFee(calldata_.borrowAmount)\n );\n (memoryData.borrowShareToAmount,) =\n yieldBox.withdraw(assetId, address(this), address(leverageExecutor), 0, borrowShare);\n }\n {\n amountOut = leverageExecutor.getCollateral(\n collateralId,\n address(asset),\n address(collateral),\n memoryData.supplyShareToAmount + memoryData.borrowShareToAmount,\n calldata_.from,\n calldata_.data\n );\n }\n uint256 collateralShare = yieldBox.toShare(collateralId, amountOut, false);\n address(asset).safeApprove(address(yieldBox), type(uint256).max);\n yieldBox.depositAsset(collateralId, address(this), address(this), 0, collateralShare); // TODO Check for rounding attack?\n address(asset).safeApprove(address(yieldBox), 0);\n\n if (collateralShare == 0) revert CollateralShareNotValid();\n _allowedBorrow(calldata_.from, collateralShare);\n _addCollateral(calldata_.from, calldata_.from, false, 0, collateralShare);\n }\n```\n | medium |
```\nfunction setMinimumTokenBalanceForAutoDividends(uint256 value) public onlyOwner {\n dividendTracker.setMinimumTokenBalanceForAutoDividends(value);\n}\n```\n | none |
```\n return (uint32(block.timestamp) -\n _liquidationDelay -\n lastRepaidTimestamp(_bidId) >\n bidDefaultDuration[_bidId]);\n```\n | medium |
```\nconstructor () {\n address msgSender = _msgSender();\n _owner = msgSender;\n emit OwnershipTransferred(address(0), msgSender);\n}\n```\n | none |
```\nFile: contracts/libraries/LibOracle.sol\n\n85 uint256 twapPriceInEther = (twapPrice / Constants.DECIMAL_USDC) * 1 ether;\n86 uint256 twapPriceInv = twapPriceInEther.inv();\n87 if (twapPriceInEther == 0) {\n88 revert Errors.InvalidTwapPrice(); // @audit : unreachable code\n89 }\n```\n | low |
```\nMUST return the maximum amount of shares that could be transferred from `owner` through `redeem` and not cause a revert, which MUST NOT be higher than the actual maximum that would be accepted (it should underestimate if necessary).\n\nMUST factor in both global and user-specific limits, like if redemption is entirely disabled (even temporarily) it MUST return 0.\n```\n | medium |
```\n function getSellRate(address \_srcAddr, address \_destAddr, uint \_srcAmount, bytes memory) public override view returns (uint rate) {\n (rate, ) = KyberNetworkProxyInterface(KYBER\_INTERFACE)\n .getExpectedRate(IERC20(\_srcAddr), IERC20(\_destAddr), \_srcAmount);\n\n // multiply with decimal difference in src token\n rate = rate \* (10\*\*(18 - getDecimals(\_srcAddr)));\n // divide with decimal difference in dest token\n rate = rate / (10\*\*(18 - getDecimals(\_destAddr)));\n }\n```\n | high |
```\npragma solidity ^0.8;\n```\n | low |
```\nfunction toUint256Safe(int256 a) internal pure returns (uint256) {\n require(a >= 0);\n return uint256(a);\n}\n```\n | none |
```\nassembly {\n // store selector of destination function\n let freeMemPtr := 0\n if gt(customEgressSelector, 0) {\n mstore(0x0, customEgressSelector)\n freeMemPtr := add(freeMemPtr, 4)\n }\n\n // adjust the calldata offset, if we should ignore the selector\n let calldataOffset := 0\n if gt(ignoreIngressSelector, 0) {\n calldataOffset := 4\n }\n\n // copy calldata to memory\n calldatacopy(\n freeMemPtr,\n calldataOffset,\n calldatasize()\n )\n```\n | low |
```\n uint256 latestTimestamp = global.latest == 0 ? 0 : oracles[global.latest].provider.latest().timestamp;\n if (uint256(oracles[global.latest].timestamp) > latestTimestamp) return false;\n```\n | medium |
```\nfunction mod(uint256 a, uint256 b) internal pure returns (uint256) {\n return mod(a, b, "SafeMath: modulo by zero");\n}\n```\n | none |
```\nfunction isExcludedFromFee(address account) public view returns(bool) {\n return _isExcludedFromFee[account];\n}\n```\n | none |
```\nsharesOwed = convertToSharesFromRestakingTokens(asset, amountIn);\n```\n | medium |
```\nconstructor(string memory name_, string memory symbol_) {\n _name = name_;\n _symbol = symbol_;\n}\n```\n | none |
```\nfunction setMaxSupplies(uint256[] calldata \_ids, uint256[] calldata \_newMaxSupplies) external onlyOwner() {\n require(\_ids.length == \_newMaxSupplies.length, "SWSupplyManager#setMaxSupply: INVALID\_ARRAYS\_LENGTH");\n\n // Can only \*decrease\* a max supply\n // Can't set max supply back to 0\n for (uint256 i = 0; i < \_ids.length; i++ ) {\n if (maxSupply[\_ids[i]] > 0) {\n require(\n 0 < \_newMaxSupplies[i] && \_newMaxSupplies[i] < maxSupply[\_ids[i]],\n "SWSupplyManager#setMaxSupply: INVALID\_NEW\_MAX\_SUPPLY"\n );\n }\n maxSupply[\_ids[i]] = \_newMaxSupplies[i];\n }\n\n emit MaxSuppliesChanged(\_ids, \_newMaxSupplies);\n}\n```\n | medium |
```\nfunction tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b == 0) return (false, 0);\n return (true, a % b);\n }\n}\n```\n | none |
```\n if (maxFCash < fCashAmount) {\n // NOTE: lending at zero\n uint256 fCashAmountExternal = fCashAmount * precision / uint256(Constants.INTERNAL_TOKEN_PRECISION);\n require(fCashAmountExternal <= depositAmountExternal);\n\n // NOTE: Residual (depositAmountExternal - fCashAmountExternal) will be transferred\n // back to the account\n NotionalV2.depositUnderlyingToken{value: msgValue}(address(this), currencyId, fCashAmountExternal);\n } else if (isETH || hasTransferFee || getCashBalance() > 0) {\n```\n | medium |
```\nfunction log2(uint256 value) internal pure returns (uint256) {\n uint256 result = 0;\n unchecked {\n if (value >> 128 > 0) {\n value >>= 128;\n result += 128;\n }\n if (value >> 64 > 0) {\n value >>= 64;\n result += 64;\n }\n if (value >> 32 > 0) {\n value >>= 32;\n result += 32;\n }\n if (value >> 16 > 0) {\n value >>= 16;\n result += 16;\n }\n if (value >> 8 > 0) {\n value >>= 8;\n result += 8;\n }\n if (value >> 4 > 0) {\n value >>= 4;\n result += 4;\n }\n if (value >> 2 > 0) {\n value >>= 2;\n result += 2;\n }\n if (value >> 1 > 0) {\n result += 1;\n }\n }\n return result;\n}\n```\n | none |
```\n function rebalanceXChain(uint256 _slippage, uint256 _relayerFee) external payable {\n require(state == State.SendingFundsXChain, stateError);\n\n\n if (amountToSendXChain > getVaultBalance()) pullFunds(amountToSendXChain);\n if (amountToSendXChain > getVaultBalance()) amountToSendXChain = getVaultBalance();\n\n\n vaultCurrency.safeIncreaseAllowance(xProvider, amountToSendXChain);\n IXProvider(xProvider).xTransferToController{value: msg.value}(\n vaultNumber,\n amountToSendXChain,\n address(vaultCurrency),\n _slippage,\n _relayerFee\n );\n\n\n emit RebalanceXChain(vaultNumber, amountToSendXChain, address(vaultCurrency));\n\n\n amountToSendXChain = 0;\n settleReservedFunds();\n }\n```\n | medium |
```\n uint88 shares = eth * (timeTillMatch / 1 days);\n```\n | medium |
```\nfunction delegateMgCvg(uint256 _tokenId, address _to, uint96 _percentage) external onlyTokenOwner(_tokenId) {\n require(_percentage <= 100, "INVALID_PERCENTAGE");\n\n uint256 _delegateesLength = delegatedMgCvg[_tokenId].length;\n require(_delegateesLength < maxMgDelegatees, "TOO_MUCH_DELEGATEES");\n\n uint256 tokenIdsDelegated = mgCvgDelegatees[_to].length;\n require(tokenIdsDelegated < maxTokenIdsDelegated, "TOO_MUCH_MG_TOKEN_ID_DELEGATED");\n```\n | medium |
```\nfunction getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n}\n```\n | none |
```\nfunction _addTokenToAllTokensEnumeration(uint256 tokenId) private {\n _allTokensIndex[tokenId] = _allTokens.length;\n _allTokens.push(tokenId);\n}\n```\n | none |
```\nfunction increment(Counter storage counter) internal {\n unchecked {\n counter._value += 1;\n }\n}\n```\n | none |
```\nfunction functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n) internal returns (bytes memory) {\n return _functionCallWithValue(target, data, 0, errorMessage);\n}\n```\n | none |
```\nfunction create(\n uint256 maxLoanDur\_,\n uint256 maxFundDur\_,\n address arbiter\_,\n bool compoundEnabled\_,\n uint256 amount\_\n) external returns (bytes32 fund) {\n require(fundOwner[msg.sender].lender != msg.sender || msg.sender == deployer); // Only allow one loan fund per address\n```\n | medium |
```\nif (validatorDetails.cap > 0 && newValidatorCap == 0) {\n // If there are active deposits, queue the operator for strategy exit.\n if (activeDeposits > 0) {\n -> operatorDetails.queueOperatorStrategyExit(operatorId, BEACON_CHAIN_STRATEGY);\n .\n }\n .\n } else if (validatorDetails.cap == 0 && newValidatorCap > 0) {\n .\n } else {\n .\n }\n```\n | medium |
```\nfunction approve(address spender, uint256 amount) public override returns (bool) {\n _approve(_msgSender(), spender, amount);\n return true;\n}\n```\n | none |
```\nminRoundId=1\nmaxRoundId=1001\n\n-> \n\nminRoundId=1\nmaxRoundId=501\n\n-> \n\nminRoundId=1\nmaxRoundId=251\n\n-> \n\nminRoundId=1\nmaxRoundId=126\n\n-> \n\nminRoundId=1\nmaxRoundId=63\n\n-> \n\nminRoundId=1\nmaxRoundId=32\n\n-> \n\nminRoundId=1\nmaxRoundId=16\n\n-> \n\nminRoundId=1\nmaxRoundId=8\n\n-> \n\nminRoundId=1\nmaxRoundId=4\n\n-> \n\nminRoundId=1\nmaxRoundId=2\n\nNow the loop terminates because\nminRoundId + 1 !< maxRoundId\n```\n | medium |
```\n// File: test/foundry/strategies/RFPSimpleStrategy.t.sol:RFPSimpleStrategyTest\n// $ forge test --match-test "test_registrationIsBlockedWhenThePoolIsCreatedWithUseRegistryIsTrue" -vvv\n//\n function test_registrationIsBlockedWhenThePoolIsCreatedWithUseRegistryIsTrue() public {\n // The registerRecipient() function does not work then the strategy was created using the\n // useRegistryAnchor = true.\n //\n bool useRegistryAnchorTrue = true;\n RFPSimpleStrategy custom_strategy = new RFPSimpleStrategy(address(allo()), "RFPSimpleStrategy");\n\n vm.prank(pool_admin());\n poolId = allo().createPoolWithCustomStrategy(\n poolProfile_id(),\n address(custom_strategy),\n abi.encode(maxBid, useRegistryAnchorTrue, metadataRequired),\n NATIVE,\n 0,\n poolMetadata,\n pool_managers()\n );\n //\n // Create profile1 metadata and anchor\n Metadata memory metadata = Metadata({protocol: 1, pointer: "metadata"});\n address anchor = profile1_anchor();\n bytes memory data = abi.encode(anchor, 1e18, metadata);\n //\n // Profile1 member registers to the pool but it reverted by RECIPIENT_ERROR\n vm.startPrank(address(profile1_member1()));\n vm.expectRevert(abi.encodeWithSelector(RECIPIENT_ERROR.selector, address(anchor)));\n allo().registerRecipient(poolId, data);\n }\n```\n | medium |
```\nfunction _incrementDeposit(address account, uint256 amount) internal {\n DepositInfo storage info = deposits[account];\n uint256 newAmount = info.deposit + amount;\n require(newAmount <= type(uint112).max, "deposit overflow");\n info.deposit = uint112(newAmount);\n}\n```\n | none |
```\nif (getCancelled(\_proposalID)) {\n // Cancelled by the proposer?\n return ProposalState.Cancelled;\n // Has it been executed?\n} else if (getExecuted(\_proposalID)) {\n return ProposalState.Executed;\n // Has it expired?\n} else if (block.number >= getExpires(\_proposalID)) {\n return ProposalState.Expired;\n // Vote was successful, is now awaiting execution\n} else if (votesFor >= getVotesRequired(\_proposalID)) {\n return ProposalState.Succeeded;\n // Is the proposal pending? Eg. waiting to be voted on\n} else if (block.number <= getStart(\_proposalID)) {\n return ProposalState.Pending;\n // The proposal is active and can be voted on\n} else if (block.number <= getEnd(\_proposalID)) {\n return ProposalState.Active;\n} else {\n // Check the votes, was it defeated?\n // if (votesFor <= votesAgainst || votesFor < getVotesRequired(\_proposalID))\n return ProposalState.Defeated;\n}\n```\n | low |
```\nfunction changeMaintainer(\n bytes calldata password,\n bytes32 newPasswordHash,\n address newMaintainer\n)\n external\n virtual\n override\n onlyPortal\n whenNotPaused\n returns (bool success)\n{\n require(\n SELF.PASSWORD\_HASH == bytes32(0) ||\n SELF.PASSWORD\_HASH ==\n keccak256(abi.encodePacked(SELF.ID, password))\n );\n SELF.PASSWORD\_HASH = newPasswordHash;\n\n \_refreshSenate(newMaintainer);\n\n success = true;\n}\n```\n | medium |
```\n function updateTrust(address borrower, uint96 trustAmount) external onlyMember(msg.sender) whenNotPaused {\n// rest of code\n uint256 voucheesLength = vouchees[staker].length;\n if (voucheesLength >= maxVouchers) revert MaxVouchees();\n\n\n uint256 voucherIndex = vouchers[borrower].length;\n voucherIndexes[borrower][staker] = Index(true, uint128(voucherIndex));\n vouchers[borrower].push(Vouch(staker, trustAmount, 0, 0)); /**** don't check maxVouchers****/\n```\n | medium |
```\nfunction functionCall(address target, bytes memory data)\n internal\n returns (bytes memory)\n{\n return functionCall(target, data, "Address: low-level call failed");\n}\n```\n | none |
```\nfunction recreateBlockheaders(uint \_blockNumber, bytes[] memory \_blockheaders) public {\n\n bytes32 currentBlockhash = blockhashMapping[\_blockNumber];\n require(currentBlockhash != 0x0, "parentBlock is not available");\n\n bytes32 calculatedHash = reCalculateBlockheaders(\_blockheaders, currentBlockhash);\n require(calculatedHash != 0x0, "invalid headers");\n```\n | medium |
```\n _withdraw(_totalSupply, _totalSupply);\n```\n | high |
```\n function getMedianPriceIfDeviation(\n uint256[] memory prices_,\n bytes memory params_\n ) public pure returns (uint256) {\n // Misconfiguration\n if (prices_.length < 3) revert SimpleStrategy_PriceCountInvalid(prices_.length, 3);\n\n237 uint256[] memory nonZeroPrices = _getNonZeroArray(prices_);\n\n // Return 0 if all prices are 0\n if (nonZeroPrices.length == 0) return 0;\n\n // Cache first non-zero price since the array is sorted in place\n uint256 firstNonZeroPrice = nonZeroPrices[0];\n\n // If there are not enough non-zero prices to calculate a median, return the first non-zero price\n246 if (nonZeroPrices.length < 3) return firstNonZeroPrice;\n\n uint256[] memory sortedPrices = nonZeroPrices.sort();\n\n // Get the average and median and abort if there's a problem\n // The following two values are guaranteed to not be 0 since sortedPrices only contains non-zero values and has a length of 3+\n uint256 averagePrice = _getAveragePrice(sortedPrices);\n253 uint256 medianPrice = _getMedianPrice(sortedPrices);\n\n if (params_.length != DEVIATION_PARAMS_LENGTH) revert SimpleStrategy_ParamsInvalid(params_);\n uint256 deviationBps = abi.decode(params_, (uint256));\n if (deviationBps <= DEVIATION_MIN || deviationBps >= DEVIATION_MAX)\n revert SimpleStrategy_ParamsInvalid(params_);\n\n // Check the deviation of the minimum from the average\n uint256 minPrice = sortedPrices[0];\n262 if (((averagePrice - minPrice) * 10000) / averagePrice > deviationBps) return medianPrice;\n\n // Check the deviation of the maximum from the average\n uint256 maxPrice = sortedPrices[sortedPrices.length - 1];\n266 if (((maxPrice - averagePrice) * 10000) / averagePrice > deviationBps) return medianPrice;\n\n // Otherwise, return the first non-zero value\n return firstNonZeroPrice;\n }\n```\n | medium |
```\n contract UXDGovernor is\n ReentrancyGuard,\n Governor,\n GovernorVotes,\n GovernorVotesQuorumFraction,\n GovernorTimelockControl,\n GovernorCountingSimple,\n GovernorSettings\n```\n | medium |
```\nif (!router.withdraws(transferId)) {\n router.withdraw(\_request, \_sigs, \_signers, \_powers);\n}\n```\n | high |
```\nconstructor() {\n _paused = false;\n}\n```\n | none |
```\nfunction distributeETH(\n address split,\n address[] calldata accounts,\n uint32[] calldata percentAllocations,\n uint32 distributorFee,\n address distributorAddress\n) external override validSplit(accounts, percentAllocations, distributorFee) {\n // use internal fn instead of modifier to avoid stack depth compiler errors\n _validSplitHash(split, accounts, percentAllocations, distributorFee);\n _distributeETH(\n split,\n accounts,\n percentAllocations,\n distributorFee,\n distributorAddress\n );\n}\n```\n | none |
```\nfunction \_poolBalanceIsSufficient(address \_collateral) internal view returns (bool) {\n return controller.balanceOf(address(reserve), \_collateral) >= collateralsToBeClaimed[\_collateral];\n}\n```\n | medium |
```\n if (feeToken == ETH) \n {uint256 totalFee = (gasUsed + GAS_OVERHEAD_NATIVE) * tx.gasprice;\n totalFee = _applyMultiplier(totalFee);\n return (totalFee, recipient, TokenTransfer._nativeTransferExec(recipient, totalFee));\n } else {uint256 totalFee = (gasUsed + GAS_OVERHEAD_ERC20) * tx.gasprice;\n // Convert fee amount value in fee tokenuint256 feeToCollect =PriceFeedManager(_addressProvider.priceFeedManager()).getTokenXPriceInY(totalFee, ETH, feeToken);\n feeToCollect = _applyMultiplier(feeToCollect);\n return (feeToCollect, recipient, TokenTransfer._erc20TransferExec(feeToken, recipient, feeToCollect));}\n```\n | high |
```\nuint256 currentThreshold = safe.getThreshold();\nuint256 newThreshold;\nuint256 target = targetThreshold; // save SLOADs\n\nif (validSignerCount <= target && validSignerCount != currentThreshold) {\n newThreshold = validSignerCount;\n} else if (validSignerCount > target && currentThreshold < target) {\n newThreshold = target;\n}\nif (newThreshold > 0) { // rest of code update safe threshold // rest of code }\n```\n | medium |
```\n/// @notice Can be used to delegate call to the TradingModule's implementation in order to execute\n/// a trade.\nfunction \_executeTrade(\n uint16 dexId,\n Trade memory trade\n) internal returns (uint256 amountSold, uint256 amountBought) {\n (bool success, bytes memory result) = nProxy(payable(address(TRADING\_MODULE))).getImplementation()\n .delegatecall(abi.encodeWithSelector(ITradingModule.executeTrade.selector, dexId, trade));\n require(success);\n (amountSold, amountBought) = abi.decode(result, (uint256, uint256));\n}\n\n/// @notice Can be used to delegate call to the TradingModule's implementation in order to execute\n/// a trade.\nfunction \_executeTradeWithDynamicSlippage(\n uint16 dexId,\n Trade memory trade,\n uint32 dynamicSlippageLimit\n) internal returns (uint256 amountSold, uint256 amountBought) {\n (bool success, bytes memory result) = nProxy(payable(address(TRADING\_MODULE))).getImplementation()\n .delegatecall(abi.encodeWithSelector(\n ITradingModule.executeTradeWithDynamicSlippage.selector,\n dexId, trade, dynamicSlippageLimit\n )\n );\n require(success);\n (amountSold, amountBought) = abi.decode(result, (uint256, uint256));\n}\n```\n | low |
```\nbool isInitialized;\n```\n | low |
```\nfunction functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n}\n```\n | none |
```\n function claimProceeds(\n uint96 lotId_,\n bytes calldata callbackData_\n ) external override nonReentrant {\n \n // rest of code\n\n (uint96 purchased_, uint96 sold_, uint96 payoutSent_) =\n _getModuleForId(lotId_).claimProceeds(lotId_);\n\n // rest of code.\n\n // Refund any unused capacity and curator fees to the address dictated by the callbacks address\n // By this stage, a partial payout (if applicable) and curator fees have been paid, leaving only the payout amount (`totalOut`) remaining.\n uint96 prefundingRefund = routing.funding + payoutSent_ - sold_;\n unchecked {\n routing.funding -= prefundingRefund;\n }\n```\n | high |
```\n function executeModule(ITOFT.Module _module, bytes memory _data, bool _forwardRevert)\n external\n payable\n whenNotPaused\n returns (bytes memory returnData)\n {\n// rest of code\n function sendPacket(LZSendParam calldata _lzSendParam, bytes calldata _composeMsg)\n public\n payable\n whenNotPaused\n returns (MessagingReceipt memory msgReceipt, OFTReceipt memory oftReceipt)\n {\n```\n | medium |
```\nfunction changeHatToggle(uint256 _hatId, address _newToggle) external {\n if (_newToggle == address(0)) revert ZeroAddress();\n\n _checkAdmin(_hatId);\n Hat storage hat = _hats[_hatId];\n\n if (!_isMutable(hat)) {\n revert Immutable();\n }\n\n hat.toggle = _newToggle;\n\n emit HatToggleChanged(_hatId, _newToggle);\n}\n```\n | medium |
```\nfunction _getCurrentSupply() private view returns(uint256, uint256) {\n uint256 rSupply = _rTotal;\n uint256 tSupply = _tTotal; \n for (uint256 i = 0; i < _excluded.length; i++) {\n if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);\n rSupply = rSupply - _rOwned[_excluded[i]];\n tSupply = tSupply - _tOwned[_excluded[i]];\n }\n if (rSupply < (_rTotal / _tTotal)) return (_rTotal, _tTotal);\n return (rSupply, tSupply);\n}\n```\n | none |
```\nfunction governorAddPoolMultiplier(\n uint256 \_pid,\n uint64 lockLength,\n uint64 newRewardsMultiplier\n) external onlyGovernor {\n PoolInfo storage pool = poolInfo[\_pid];\n uint256 currentMultiplier = rewardMultipliers[\_pid][lockLength];\n // if the new multplier is less than the current multiplier,\n // then, you need to unlock the pool to allow users to withdraw\n if (newRewardsMultiplier < currentMultiplier) {\n pool.unlocked = true;\n }\n rewardMultipliers[\_pid][lockLength] = newRewardsMultiplier;\n\n emit LogPoolMultiplier(\_pid, lockLength, newRewardsMultiplier);\n}\n```\n | medium |
```\n// tokenSpent and tokenReceived are immutable\ntokenSpent = \_tokenSpent;\ntokenReceived = \_tokenReceived;\n```\n | low |
```\nfunction _validatePaymasterPrepayment(uint256 opIndex, UserOperation calldata op, UserOpInfo memory opInfo, uint256 requiredPreFund, uint256 gasUsedByValidateAccountPrepayment)\ninternal returns (bytes memory context, uint256 validationData) {\nunchecked {\n MemoryUserOp memory mUserOp = opInfo.mUserOp;\n uint256 verificationGasLimit = mUserOp.verificationGasLimit;\n require(verificationGasLimit > gasUsedByValidateAccountPrepayment, "AA41 too little verificationGas");\n uint256 gas = verificationGasLimit - gasUsedByValidateAccountPrepayment;\n\n address paymaster = mUserOp.paymaster;\n DepositInfo storage paymasterInfo = deposits[paymaster];\n uint256 deposit = paymasterInfo.deposit;\n if (deposit < requiredPreFund) {\n revert FailedOp(opIndex, "AA31 paymaster deposit too low");\n }\n paymasterInfo.deposit = uint112(deposit - requiredPreFund);\n try IPaymaster(paymaster).validatePaymasterUserOp{gas : gas}(op, opInfo.userOpHash, requiredPreFund) returns (bytes memory _context, uint256 _validationData){\n context = _context;\n validationData = _validationData;\n } catch Error(string memory revertReason) {\n revert FailedOp(opIndex, string.concat("AA33 reverted: ", revertReason));\n } catch {\n revert FailedOp(opIndex, "AA33 reverted (or OOG)");\n }\n}\n}\n```\n | none |
```\nuint256 barBeforeBalance = bar.balanceOf(address(this));\nuint256 sushiBeforeBalance = sushi.balanceOf(address(this));\n\nbar.leave(requiredShares);\n\nuint256 barAfterBalance = bar.balanceOf(address(this));\nuint256 sushiAfterBalance = sushi.balanceOf(address(this));\n\nuint256 barBalanceDiff = barBeforeBalance.sub(barAfterBalance);\nuint256 sushiBalanceDiff = sushiAfterBalance.sub(sushiBeforeBalance);\n\nbalances[msg.sender] = balances[msg.sender].sub(barBalanceDiff);\n```\n | low |
```\nfunction functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n) internal returns (bytes memory) {\n require(address(this).balance >= value, "Address: insufficient balance for call");\n require(isContract(target), "Address: call to non-contract");\n\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return _verifyCallResult(success, returndata, errorMessage);\n}\n```\n | none |
```\n function onUndelegate(address delegator, uint amount) external {\n // limitation only applies to the operator, others can always undelegate\n if (delegator != owner) { return; }\n\n uint actualAmount = amount < balanceOf(owner) ? amount : balanceOf(owner); //@audit amount:DATA, balanceOf:Operator\n uint balanceAfter = balanceOf(owner) - actualAmount;\n uint totalSupplyAfter = totalSupply() - actualAmount;\n require(1 ether * balanceAfter >= totalSupplyAfter * streamrConfig.minimumSelfDelegationFraction(), "error_selfDelegationTooLow");\n }\n```\n | high |
```\nfunction requestWithdraw(\n Types.State storage state,\n address from,\n uint256 primaryAmount,\n uint256 secondaryAmount\n)\n external\n{\n require(isWithdrawValid(state, msg.sender, from, primaryAmount, secondaryAmount), Errors.WITHDRAW_INVALID);\n state.pendingPrimaryWithdraw[msg.sender] = primaryAmount;\n state.pendingSecondaryWithdraw[msg.sender] = secondaryAmount;\n state.withdrawExecutionTimestamp[msg.sender] = block.timestamp + state.withdrawTimeLock;\n emit RequestWithdraw(msg.sender, primaryAmount, secondaryAmount, state.withdrawExecutionTimestamp[msg.sender]);\n}\n```\n | medium |
```\nfunction makeSplitImmutable(address split)\n external\n override\n onlySplitController(split)\n{\n delete splits[split].newPotentialController;\n emit ControlTransfer(split, splits[split].controller, address(0));\n splits[split].controller = address(0);\n}\n```\n | none |
```\n IERC20 weth = IERC20(address(0xc778417E063141139Fce010982780140Aa0cD5Ab)); // rinkeby weth\n```\n | low |
```\ncontract TokenBridge is ITokenBridge, PausableUpgradeable, OwnableUpgradeable {\n```\n | low |
```\n if (isLong) {\n uint swapFeeBP = getSwapFeeBP(isLong, true, collateralDelta);\n collateralDelta = (collateralDelta * (BASIS_POINTS_DIVISOR + swapFeeBP)) / BASIS_POINTS_DIVISOR;\n }\n // add margin fee\n // when we increase position, fee always got deducted from collateral\n collateralDelta += _getPositionFee(currentPos.size, sizeDelta, currentPos.entryFundingRate);\n```\n | high |
```\nfunction convertToPeUSD(address user, uint256 eusdAmount) public {\n require(\_msgSender() == user || \_msgSender() == address(this), "MDM");\n require(eusdAmount != 0, "ZA");\n require(EUSD.balanceOf(address(this)) + eusdAmount <= configurator.getEUSDMaxLocked(),"ESL");\n```\n | medium |
```\nfunction _claimRewards(\n address gauge,\n address defaultToken,\n address sendTo\n) internal returns (uint256[] memory amounts, address[] memory tokens) {\n // rest of code \n\n // Record balances before claiming\n for (uint256 i = 0; i < totalLength; ++i) {\n // The totalSupply check is used to identify stash tokens, which can\n // substitute as rewardToken but lack a "balanceOf()"\n if (IERC20(rewardTokens[i]).totalSupply() > 0) {\n balancesBefore[i] = IERC20(rewardTokens[i]).balanceOf(account);\n }\n }\n\n // Claim rewards\n bool result = rewardPool.getReward(account, /*_claimExtras*/ true);\n if (!result) {\n revert RewardAdapter.ClaimRewardsFailed();\n }\n\n // Record balances after claiming and calculate amounts claimed\n for (uint256 i = 0; i < totalLength; ++i) {\n uint256 balance = 0;\n // Same check for "stash tokens"\n if (IERC20(rewardTokens[i]).totalSupply() > 0) {\n balance = IERC20(rewardTokens[i]).balanceOf(account);\n }\n\n amountsClaimed[i] = balance - balancesBefore[i];\n\n if (sendTo != address(this) && amountsClaimed[i] > 0) {\n IERC20(rewardTokens[i]).safeTransfer(sendTo, amountsClaimed[i]);\n }\n }\n\n RewardAdapter.emitRewardsClaimed(rewardTokens, amountsClaimed);\n\n return (amountsClaimed, rewardTokens);\n}\n```\n | medium |
```\n// If the funding timeout has elapsed, punish the funder too!\nif (block.timestamp > \_d.fundingProofTimerStart + TBTCConstants.getFundingTimeout()) {\n address(0).transfer(address(this).balance); // Burn it all down (fire emoji)\n \_d.setFailedSetup();\n```\n | medium |
```\nuint256 currentSharePrice = ethStEthPool.get\_virtual\_price();\nif (currentSharePrice > prevSharePrice) {\n // claim any gain on lp token yields\n uint256 contractLpTokenBalance = lpToken.balanceOf(address(this));\n uint256 totalLpBalance = contractLpTokenBalance +\n baseRewardPool.balanceOf(address(this));\n uint256 yieldEarned = (currentSharePrice - prevSharePrice) \*\n totalLpBalance;\n```\n | high |
```\nfunction liquidateSecondary(\n address asset,\n MTypes.BatchMC[] memory batches,\n uint88 liquidateAmount,\n bool isWallet\n ) external onlyValidAsset(asset) isNotFrozen(asset) nonReentrant {\n // Initial code\n\n emit Events.LiquidateSecondary(asset, batches, msg.sender, isWallet);\n }\n```\n | low |
```\n function increaseLiquidity(IncreaseLiquidityParams calldata params)\n external payable override checkDeadline(params.deadline)\n returns (\n uint128 liquidity, uint256 amount0, uint256 amount1)\n {\n Position storage position = _positions[params.tokenId];\n PoolAddress.PoolKey memory poolKey = _poolIdToPoolKey[position.poolId];\n IUniswapV3Pool pool;\n (liquidity, amount0, amount1, pool) = addLiquidity(\n```\n | high |
```\nfunction submitNewGuardianSet(bytes memory _vm) public {\n // rest of code\n\n // Trigger a time-based expiry of current guardianSet\n expireGuardianSet(getCurrentGuardianSetIndex());\n\n // Add the new guardianSet to guardianSets\n storeGuardianSet(upgrade.newGuardianSet, upgrade.newGuardianSetIndex);\n\n // Makes the new guardianSet effective\n updateGuardianSetIndex(upgrade.newGuardianSetIndex);\n}\n```\n | low |
```\nassembly ("memory-safe") {\n // // rest of code\n liabilities0 := div(liabilities0, strain) // @audit rounds down to 0 <-\n liabilities1 := div(liabilities1, strain) // @audit rounds down to 0 <-\n // // rest of code\n}\n```\n | medium |
```\nfunction sub(\n uint256 a,\n uint256 b,\n string memory errorMessage\n) internal pure returns (uint256) {\n unchecked {\n require(b <= a, errorMessage);\n return a - b;\n }\n}\n```\n | none |
```\nfunction setMaxGauges(uint256 newMax) external requiresAuth {\n uint256 oldMax = maxGauges;\n maxGauges = newMax;\n\n emit MaxGaugesUpdate(oldMax, newMax);\n}\n```\n | low |
```\nabstract contract ERC721PausableUpgradeable is Initializable, ERC721Upgradeable, PausableUpgradeable {\n function \_\_ERC721Pausable\_init() internal initializer {\n \_\_Context\_init\_unchained(); \n \_\_ERC165\_init\_unchained();\n \_\_Pausable\_init\_unchained();\n \_\_ERC721Pausable\_init\_unchained();\n }\n```\n | low |
```\nfunction transferFrom(\n address sender,\n address recipient,\n uint256 amount\n) external override returns (bool) {\n address spender = msg.sender;\n //check allowance requirement\n _spendAllowance(sender, spender, amount);\n return _transferFrom(sender, recipient, amount);\n}\n```\n | none |
```\nfunction excludeFromFee(address account) public onlyOwner {\n _isExcludedFromFee[account] = true;\n emit ExcludeFromFeeUpdated(account);\n}\n```\n | none |
```\nRunning 1 test for test/scenario/BorrowAndRepay.scenario.t.sol:BorrowAndRepay_Scenario_Test\n[PASS] testScenario_Poc() (gas: 799155)\nLogs:\n 100 initial pool balance. This is also the amount deposited into tranche\n warp 2 minutes into future\n mint was used rather than deposit to ensure no rounding error. This a UTILISATION manipulation attack not a share inflation attack\n 22 shares were burned in exchange for 100000 assets. Users.LiquidityProvider only deposited 100 asset in the tranche but withdrew 100000 assets!\n```\n | medium |
```\nfunction updatePillMintMerkleRoot(bytes32 hash)\n external\n onlyOwner\n returns (bool)\n{\n merkleRootOfPillMintWhitelistAddresses = hash;\n emit UpdatedMerkleRootOfPillMint(hash, msg.sender);\n\n return true;\n}\n```\n | none |
```\npoolInfo.accTidalPerShare = poolInfo.accTidalPerShare.add(\n amount\_.mul(SHARE\_UNITS)).div(poolInfo.totalShare);\n```\n | high |
```\nfunction byteLength(ShortString sstr) internal pure returns (uint256) {\n uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;\n if (result > 31) {\n revert InvalidShortString();\n }\n return result;\n}\n```\n | none |
```\nfunction plunder(\n address erc721,\n uint256 tokenId,\n IERC20[] calldata erc20s,\n LootBox.WithdrawERC721[] calldata erc721s,\n LootBox.WithdrawERC1155[] calldata erc1155s\n) external {\n address payable owner = payable(IERC721(erc721).ownerOf(tokenId));\n```\n | medium |
```\nfunction getTellorCurrentValue(bytes32 _queryId)\n ..SNIP..\n // retrieve most recent 20+ minute old value for a queryId. the time buffer allows time for a bad value to be disputed\n (, bytes memory data, uint256 timestamp) = tellor.getDataBefore(_queryId, block.timestamp - 20 minutes);\n uint256 _value = abi.decode(data, (uint256));\n if (timestamp == 0 || _value == 0) return (false, _value, timestamp);\n```\n | medium |
```\nFile: wfCashLogic.sol\n function _lendLegacy(\nFile: wfCashLogic.sol\n // If deposit amount external is in excess of the cost to purchase fCash amount (often the case),\n // then we need to return the difference between postTradeCash - preTradeCash. This is done because\n // the encoded trade does not automatically withdraw the entire cash balance in case the wrapper\n // is holding a cash balance.\n uint256 preTradeCash = getCashBalance();\n\n BalanceActionWithTrades[] memory action = EncodeDecode.encodeLegacyLendTrade(\n currencyId,\n getMarketIndex(),\n depositAmountExternal,\n fCashAmount,\n minImpliedRate\n );\n // Notional will return any residual ETH as the native token. When we _sendTokensToReceiver those\n // native ETH tokens will be wrapped back to WETH.\n NotionalV2.batchBalanceAndTradeAction{value: msgValue}(address(this), action); \n\n uint256 postTradeCash = getCashBalance(); \n\n if (preTradeCash != postTradeCash) { \n // If ETH, then redeem to WETH (redeemToUnderlying == false)\n NotionalV2.withdraw(currencyId, _safeUint88(postTradeCash - preTradeCash), !isETH);\n }\n }\n```\n | high |
```\nfunction getAccountDividendsInfoAtIndex(uint256 index) external view returns (address, int256, int256,\n uint256, uint256, uint256) {\n return dividendTracker.getAccountAtIndex(index);\n}\n```\n | none |
```\n/\*\*\n \* @dev Routing Function for Flashloan Provider\n \* @param info: struct information for flashLoan\n \* @param \_flashnum: integer identifier of flashloan provider\n \*/\nfunction initiateFlashloan(FlashLoan.Info calldata info, uint8 \_flashnum) external isAuthorized override {\n if (\_flashnum == 0) {\n \_initiateGeistFlashLoan(info);\n } else if (\_flashnum == 2) {\n \_initiateCreamFlashLoan(info);\n } else {\n revert(Errors.VL\_INVALID\_FLASH\_NUMBER);\n }\n}\n```\n | high |
```\n function getMarketTokenPrice(\n DataStore dataStore,\n Market.Props memory market,\n Price.Props memory indexTokenPrice,\n Price.Props memory longTokenPrice,\n Price.Props memory shortTokenPrice,\n bytes32 pnlFactorType,\n bool maximize\n ) external view returns (int256, MarketPoolValueInfo.Props memory) {\n return\n MarketUtils.getMarketTokenPrice(\n dataStore,\n market,\n indexTokenPrice,\n longTokenPrice,\n shortTokenPrice,\n pnlFactorType,\n maximize\n );\n }\n```\n | medium |
```\n require(s.ss[token].milestoneSeason == 0, "Whitelist: Token already whitelisted");\n```\n | medium |
```\nfunction _takeLiquidity(uint256 tLiquidity) private {\n uint256 currentRate = _getRate();\n uint256 rLiquidity = tLiquidity.mul(currentRate);\n _rOwned[address(this)] = _rOwned[address(this)].add(rLiquidity);\n if (_isExcluded[address(this)])\n _tOwned[address(this)] = _tOwned[address(this)].add(tLiquidity);\n}\n```\n | none |
```\nfunction isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize, which returns 0 for contracts in\n // construction, since the code is only stored at the end of the\n // constructor execution.\n\n uint256 size;\n assembly {\n size := extcodesize(account)\n }\n return size > 0;\n}\n```\n | none |
```\nfunction swapTokensForEth(uint256 tokenAmount) private {\n // generate the uniswap pair path of token -> weth\n address[] memory path = new address[](2);\n path[0] = address(this);\n path[1] = uniswapV2Router.WETH();\n\n _approve(address(this), address(uniswapV2Router), tokenAmount);\n\n // make the swap\n uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(\n tokenAmount,\n 0, // accept any amount of ETH\n path,\n address(this),\n block.timestamp\n );\n}\n```\n | none |
```\ncontract WFTMUnwrapper {\n address constant wftm = 0x21be370D5312f44cB42ce377BC9b8a0cEF1A4C83;\n\n receive() external payable {}\n\n /\*\*\n \* @notice Convert WFTM to FTM and transfer to msg.sender\n \* @dev msg.sender needs to send WFTM before calling this withdraw\n \* @param \_amount amount to withdraw.\n \*/\n function withdraw(uint256 \_amount) external {\n IWETH(wftm).withdraw(\_amount);\n (bool sent, ) = msg.sender.call{ value: \_amount }("");\n require(sent, "Failed to send FTM");\n }\n}\n```\n | low |
```\nfunction functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, "Address: low-level static call failed");\n}\n```\n | none |
Subsets and Splits