function
stringlengths 12
63.3k
| severity
stringclasses 4
values |
|---|---|
```\nfunction setFeeReceivers(\n address ecosystem,\n address marketing1,\n address marketing2,\n address treasury\n) external authorized {\n require(\n ecosystem != address(0) && marketing1 != address(0) && marketing2 != address(0) && treasury != address(0),\n "VoxNET: zero address provided"\n );\n\n ecosystemFeeReceiver = ecosystem;\n marketingFeeReceiver1 = marketing1;\n marketingFeeReceiver2 = marketing2;\n treasuryFeeReceiver = treasury;\n\n emit FeeReceiversSet(ecosystem, marketing1, marketing2, treasury);\n}\n```\n | none |
```\nfunction _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {\n (uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _feeAddr1, _feeAddr2);\n uint256 currentRate = _getRate();\n (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);\n return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);\n}\n```\n | none |
```\nfunction _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {\n (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount);\n _tOwned[sender] = _tOwned[sender] - tAmount;\n _rOwned[sender] = _rOwned[sender] - rAmount;\n _tOwned[recipient] = _tOwned[recipient] + tTransferAmount;\n _rOwned[recipient] = _rOwned[recipient] + rTransferAmount; \n _takeLiquidity(tLiquidity);\n _reflectFee(rFee, tFee);\n emit Transfer(sender, recipient, tTransferAmount);\n}\n```\n | none |
```\nfunction resetVaultUnderlying(uint256 _vaultNumber) internal {\n vaults[_vaultNumber].totalUnderlying = 0;\n vaultStage[_vaultNumber].underlyingReceived = 0;\n vaults[_vaultNumber].totalSupply = 0;\n}\n```\n | medium |
```\nfunction executeOperation(\n address[] memory \_assets,\n uint256[] memory \_amounts,\n uint256[] memory \_fees,\n address \_initiator,\n bytes memory \_params\n) public returns (bool) {\n require(msg.sender == AAVE\_LENDING\_POOL, ERR\_ONLY\_AAVE\_CALLER);\n require(\_initiator == address(this), ERR\_SAME\_CALLER);\n\n (Task memory currTask, address proxy) = abi.decode(\_params, (Task, address));\n\n // Send FL amounts to user proxy\n for (uint256 i = 0; i < \_assets.length; ++i) {\n \_assets[i].withdrawTokens(proxy, \_amounts[i]);\n }\n\n address payable taskExecutor = payable(registry.getAddr(TASK\_EXECUTOR\_ID));\n\n // call Action execution\n IDSProxy(proxy).execute{value: address(this).balance}(\n taskExecutor,\n abi.encodeWithSelector(CALLBACK\_SELECTOR, currTask, bytes32(\_amounts[0] + \_fees[0]))\n );\n\n // return FL\n for (uint256 i = 0; i < \_assets.length; i++) {\n \_assets[i].approveToken(address(AAVE\_LENDING\_POOL), \_amounts[i] + \_fees[i]);\n }\n\n return true;\n}\n```\n | high |
```\n /**\n @dev Whitelist users\n @param _address Address of User\n */\n function setClaimBlock(address _address) external onlyRole(OPERATOR) {\n blockClaim[_address] = true;\n }\n```\n | medium |
```\n if (msg.sender != address(token)) {\n revert AccessDeniedDATATokenOnly();\n }\n```\n | medium |
```\n //@audit -- this report raises an issue regarding the lack of stale price check for the base oracle (ETH/USD price) in the oracleCircuitBreaker() only, as the 2-hour stale check and the lack of stale price check for the non-USD asset oracle were flagged as known issues\n function oracleCircuitBreaker(\n uint80 roundId,\n uint80 baseRoundId,\n int256 chainlinkPrice,\n int256 baseChainlinkPrice,\n uint256 timeStamp,\n uint256 baseTimeStamp\n ) private view { //@audit -- this report raises an issue regarding the lack of stale price check for the base oracle (ETH/USD price) in the oracleCircuitBreaker() only, as the 2-hour stale check and the lack of stale price check for the non-USD asset oracle were flagged as known issues\n bool invalidFetchData = roundId == 0 || timeStamp == 0\n || timeStamp > block.timestamp || chainlinkPrice <= 0 || baseRoundId == 0\n || baseTimeStamp == 0 || baseTimeStamp > block.timestamp\n || baseChainlinkPrice <= 0; //@audit -- lack the condition: "block.timestamp > 2 hours + baseTimeStamp"\n\n if (invalidFetchData) revert Errors.InvalidPrice();\n }\n\n function baseOracleCircuitBreaker(\n uint256 protocolPrice,\n uint80 roundId,\n int256 chainlinkPrice,\n uint256 timeStamp,\n uint256 chainlinkPriceInEth\n ) private view returns (uint256 _protocolPrice) {\n bool invalidFetchData = roundId == 0 || timeStamp == 0\n || timeStamp > block.timestamp || chainlinkPrice <= 0\n || block.timestamp > 2 hours + timeStamp; //@audit -- the baseOracleCircuitBreaker() checks this condition, but the oracleCircuitBreaker() does not check it (for the base oracle (ETH/USD price) only)\n uint256 chainlinkDiff = chainlinkPriceInEth > protocolPrice\n ? chainlinkPriceInEth - protocolPrice\n : protocolPrice - chainlinkPriceInEth;\n bool priceDeviation =\n protocolPrice > 0 && chainlinkDiff.div(protocolPrice) > 0.5 ether;\n\n // rest of code\n }\n```\n | medium |
```\nfunction deposit(\n GMXTypes.Store storage self,\n GMXTypes.DepositParams memory dp,\n bool isNative\n) external {\n // Sweep any tokenA/B in vault to the temporary trove for future compouding and to prevent\n // it from being considered as part of depositor's assets\n if (self.tokenA.balanceOf(address(this)) > 0) {\n self.tokenA.safeTransfer(self.trove, self.tokenA.balanceOf(address(this)));\n }\n if (self.tokenB.balanceOf(address(this)) > 0) {\n self.tokenB.safeTransfer(self.trove, self.tokenB.balanceOf(address(this)));\n }\n // rest of code\n}\n```\n | high |
```\nfunction changeFeeReceivers(\n address newTeamWallet,\n address newTreasuryWallet\n) external onlyOwner {\n require(\n newTeamWallet != address(0) && newTreasuryWallet != address(0),\n "New wallets must not be the ZERO address"\n );\n\n teamWallet = newTeamWallet;\n treasuryWallet = newTreasuryWallet;\n}\n```\n | none |
```\nFile: Curve2TokenConvexHelper.sol\n function reinvestReward(\n Curve2TokenConvexStrategyContext calldata context,\n ReinvestRewardParams calldata params\n ) external {\n..SNIP..\n // Make sure we are joining with the right proportion to minimize slippage\n poolContext._validateSpotPriceAndPairPrice({\n strategyContext: strategyContext,\n oraclePrice: poolContext.basePool._getOraclePairPrice(strategyContext),\n primaryAmount: primaryAmount,\n secondaryAmount: secondaryAmount\n });\n```\n | high |
```\nuint256 assetTotalSupply = asset.balanceOf(address(this));\nuint256 availableTotalSupply = assetTotalSupply.sub(totalUnclaimed);\nuint256 newSeconds = currentTimestamp.sub(lastDripTimestamp);\nuint256 nextExchangeRateMantissa = exchangeRateMantissa;\nuint256 newTokens;\nuint256 measureTotalSupply = measure.totalSupply();\n\nif (measureTotalSupply > 0 && availableTotalSupply > 0 && newSeconds > 0) {\n newTokens = newSeconds.mul(dripRatePerSecond);\n if (newTokens > availableTotalSupply) {\n newTokens = availableTotalSupply;\n }\n uint256 indexDeltaMantissa = measureTotalSupply > 0 ? FixedPoint.calculateMantissa(newTokens, measureTotalSupply) : 0;\n nextExchangeRateMantissa = nextExchangeRateMantissa.add(indexDeltaMantissa);\n\n emit Dripped(\n newTokens\n );\n}\n```\n | medium |
```\nuint amountOut = IWETH10(WETH).balanceOf(address(this));\nrequire(\n IWETH10(sp.tokenOut).balanceOf(address(this)).sub(balanceBefore) >= sp.amountOut,\n 'DAOfiV1Router: INSUFFICIENT\_OUTPUT\_AMOUNT'\n);\n```\n | high |
```\n return \_deployAccount(\n salt,\n 0\n );\n}\n\nfunction \_deployAccount(\n bytes32 salt,\n uint256 value\n)\n internal\n returns (address)\n{\n return address(new Account{salt: salt, value: value}());\n}\n```\n | low |
```\n function removeOracleSignerAfterSignal(address account) external onlyTimelockAdmin nonReentrant {\n bytes32 actionKey = _addOracleSignerActionKey(account);\n _validateAndClearAction(actionKey, "removeOracleSigner");\n\n oracleStore.removeSigner(account);\n\n EventUtils.EventLogData memory eventData;\n eventData.addressItems.initItems(1);\n eventData.addressItems.setItem(0, "account", account);\n eventEmitter.emitEventLog1(\n "RemoveOracleSigner",\n actionKey,\n eventData\n );\n }\n```\n | medium |
```\nfunction transfer(address recipient, uint256 amount) public override returns (bool) {\n _transfer(_msgSender(), recipient, amount);\n return true;\n}\n```\n | none |
```\nfor (uint256 i; i < _ownerCount - 1;) {\n ownerToCheck = _owners[i];\n\n if (!isValidSigner(ownerToCheck)) {\n // prep the swap\n data = abi.encodeWithSignature(\n "swapOwner(address,address,address)",\n // rest of code\n```\n | medium |
```\nfunction toString(uint256 value) internal pure returns (string memory) {\n unchecked {\n uint256 length = Math.log10(value) + 1;\n string memory buffer = new string(length);\n uint256 ptr;\n /// @solidity memory-safe-assembly\n assembly {\n ptr := add(buffer, add(32, length))\n }\n while (true) {\n ptr--;\n /// @solidity memory-safe-assembly\n assembly {\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\n }\n value /= 10;\n if (value == 0) break;\n }\n return buffer;\n }\n}\n```\n | none |
```\n/// @dev Prefix for all TransceiverMessage payloads\n/// This is 0x99'E''W''H'\n/// @notice Magic string (constant value set by messaging provider) that idenfies the payload as an transceiver-emitted payload.\n/// Note that this is not a security critical field. It's meant to be used by messaging providers to identify which messages are Transceiver-related.\nbytes4 constant WH_TRANSCEIVER_PAYLOAD_PREFIX = 0x9945FF10;\n```\n | low |
```\n function redeemYield(uint256 amount) external {\n if(amount == 0) revert InvalidRedemption();\n if(block.timestamp < concludeTime + delay || !concluded) revert NotConcluded();\n uint256 yieldShare = FixedPointMathLib.divWad(amount, ERC20(yt).totalSupply());\n YieldToken(yt).burnYT(msg.sender, amount);\n uint256 yieldTokensLength = yieldTokens.length;\n for(uint8 i; i < yieldTokensLength; ++i) {\n uint256 finalYield;\n if(yieldTokens[i] == depositToken) {\n finalYield = ERC20(yieldTokens[i]).balanceOf(address(this)) - depositTokenAmount;\n }\n else {\n finalYield = ERC20(yieldTokens[i]).balanceOf(address(this));\n }\n uint256 claimable = FixedPointMathLib.mulWad(finalYield, yieldShare);\n SafeTransferLib.safeTransfer(yieldTokens[i], msg.sender, claimable);\n }\n emit YieldTokenRedemption(msg.sender, amount);\n }\n```\n | medium |
```\nif (\n operators.value[\_operatorIndex].limit < \_limit &&\n StakingContractStorageLib.getLastValidatorEdit() > \_snapshot\n) {\n revert LastEditAfterSnapshot();\n}\n```\n | medium |
```\nfunction remove(UniqueAddressQueue storage baseQueue, address addrToRemove) internal returns (bool) {\n if (!contains(baseQueue, addrToRemove)) {\n return false;\n }\n\n if (baseQueue.HEAD == addrToRemove) {\n return removeFirst(baseQueue);\n }\n\n if (baseQueue.TAIL == addrToRemove) {\n return removeLast(baseQueue);\n }\n\n address prevAddr = baseQueue.queue[addrToRemove].prev;\n address nextAddr = baseQueue.queue[addrToRemove].next;\n baseQueue.queue[prevAddr].next = nextAddr;\n baseQueue.queue[nextAddr].prev = prevAddr;\n baseQueue.queueLength--;\n\n return true;\n}\n```\n | high |
```\nfunction getCurrentStage() public view returns (uint8) {\n return getStageAtBlock(getCurrentBlockNumber());\n}\n```\n | medium |
```\nfunction depositTo(address account) public payable {\n _incrementDeposit(account, msg.value);\n DepositInfo storage info = deposits[account];\n emit Deposited(account, info.deposit);\n}\n```\n | none |
```\nfunction getTknOhmPrice() public view override returns (uint256) {\n // Get stETH per wstETH (18 Decimals)\n uint256 stethPerWsteth = IWsteth(pairToken).stEthPerToken();\n\n // Get ETH per OHM (18 Decimals)\n uint256 ethPerOhm = _validatePrice(ohmEthPriceFeed.feed, ohmEthPriceFeed.updateThreshold);\n\n // Get stETH per ETH (18 Decimals)\n uint256 stethPerEth = _validatePrice(\n stethEthPriceFeed.feed,\n stethEthPriceFeed.updateThreshold\n );\n\n // Calculate wstETH per OHM (18 decimals)\n return (ethPerOhm * 1e36) / (stethPerWsteth * stethPerEth);\n}\n```\n | medium |
```\n function exerciseOptionsReceiver(address srcChainSender, bytes memory _data) public payable {\n// rest of code\n ITapiocaOptionBroker(_options.target).exerciseOption(\n _options.oTAPTokenID,\n address(this), //payment token\n _options.tapAmount\n );\n _approve(address(this), address(pearlmit), 0);\n uint256 bAfter = balanceOf(address(this));\n\n // Refund if less was used.\n if (bBefore > bAfter) {\n uint256 diff = bBefore - bAfter;\n if (diff < _options.paymentTokenAmount) {\n IERC20(address(this)).safeTransfer(_options.from, _options.paymentTokenAmount - diff);\n }\n }\n// rest of code\n```\n | high |
```\nfunction transferOwnership(address payable newOwner) external onlyOwner {\n require(newOwner != address(0), "Auth: owner address cannot be zero");\n isAuthorized[newOwner] = true;\n _transferOwnership(newOwner);\n}\n```\n | none |
```\nfunction toTypedDataHash(\n bytes32 domainSeparator,\n bytes32 structHash\n) internal pure returns (bytes32 data) {\n /// @solidity memory-safe-assembly\n assembly {\n let ptr := mload(0x40)\n mstore(ptr, "\x19\x01")\n mstore(add(ptr, 0x02), domainSeparator)\n mstore(add(ptr, 0x22), structHash)\n data := keccak256(ptr, 0x42)\n }\n}\n```\n | none |
```\n function rebalance() override public {\n uint256 ownval = getOwnValuation(); // it low enough to dive into if statement (see line below) \n (uint256 USSDamount, uint256 DAIamount) = getSupplyProportion(); // (3000e6 USSD, 2000e18 DAI)\n if (ownval < 1e6 - threshold) {\n // peg-down recovery\n BuyUSSDSellCollateral((USSDamount - DAIamount / 1e12)/2); // 500 * 1e6 = (3000e6 - 2000e18 / 1e12) / 2\n```\n | medium |
```\n/// @notice Request a new keep opening.\n/// @param \_m Minimum number of honest keep members required to sign.\n/// @param \_n Number of members in the keep.\n/// @return Address of a new keep.\nfunction requestNewKeep(uint256 \_m, uint256 \_n, uint256 \_bond)\n external\n payable\n returns (address)\n{\n IBondedECDSAKeepVendor \_keepVendor = IBondedECDSAKeepVendor(keepVendor);\n IBondedECDSAKeepFactory \_keepFactory = IBondedECDSAKeepFactory(\_keepVendor.selectFactory());\n return \_keepFactory.openKeep.value(msg.value)(\_n, \_m, msg.sender, \_bond);\n}\n```\n | high |
```\nfunction pillMintingSale(bytes32[] calldata _merkleProof)\n external\n payable\n returns (bool)\n{\n if (\n (block.timestamp >=\n defaultSaleStartTime + DEFAULT_PIXELMINT_SALE) &&\n (block.timestamp < defaultSaleStartTime + DEFAULT_PILLMINT_SALE)\n ) {\n _tokenIds++;\n\n if (pillMintWhitelistedAddresses[msg.sender] != 0)\n revert WhitelistedAddressAlreadyClaimedNFT();\n\n if ((dutchAuctionLastPrice / 2) != msg.value)\n revert InvalidBuyNFTPrice(\n (dutchAuctionLastPrice / 2),\n msg.value\n );\n\n bytes32 leaf = keccak256(abi.encodePacked(msg.sender));\n\n if (\n !MerkleProof.verify(\n _merkleProof,\n merkleRootOfPillMintWhitelistAddresses,\n leaf\n )\n ) revert InvalidMerkleProof();\n\n pillMintWhitelistedAddresses[msg.sender] = 1;\n\n emit NewNFTMintedOnPillSale(_tokenIds, msg.sender, msg.value);\n\n _mint(msg.sender, _tokenIds, 1, "");\n\n return true;\n } else {\n revert UnAuthorizedRequest();\n }\n}\n```\n | none |
```\nfunction log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = log10(value);\n return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\n }\n}\n```\n | none |
```\n function validateCommitment(IAstariaRouter.Commitment calldata commitment)\n public\n returns (bool valid, IAstariaRouter.LienDetails memory ld)\n {\n require(\n commitment.lienRequest.strategy.deadline >= block.timestamp,\n "deadline passed"\n );\n\n\n require(\n strategyValidators[commitment.lienRequest.nlrType] != address(0),\n "invalid strategy type"\n );\n\n\n bytes32 leaf;\n (leaf, ld) = IStrategyValidator(\n strategyValidators[commitment.lienRequest.nlrType]\n ).validateAndParse(\n commitment.lienRequest,\n COLLATERAL_TOKEN.ownerOf(\n commitment.tokenContract.computeId(commitment.tokenId)\n ),\n commitment.tokenContract,\n commitment.tokenId\n );\n\n\n return (\n MerkleProof.verifyCalldata(\n commitment.lienRequest.merkle.proof,\n commitment.lienRequest.merkle.root,\n leaf\n ),\n ld\n );\n }\n```\n | medium |
```\nfunction incrementNonce(uint192 key) public override {\n nonceSequenceNumber[msg.sender][key]++;\n}\n```\n | none |
```\n function test_revert_underflow() public {\n _accessController.grantRole(Roles.SOLVER_ROLE, address(this));\n _accessController.grantRole(Roles.LMP_FEE_SETTER_ROLE, address(this));\n\n // User is going to deposit 1500 asset\n _asset.mint(address(this), 1500);\n _asset.approve(address(_lmpVault), 1500);\n _lmpVault.deposit(1500, address(this));\n\n // Deployed 700 asset to DV1\n _underlyerOne.mint(address(this), 700);\n _underlyerOne.approve(address(_lmpVault), 700);\n _lmpVault.rebalance(\n address(_destVaultOne),\n address(_underlyerOne), // tokenIn\n 700,\n address(0), // destinationOut, none when sending out baseAsset\n address(_asset), // baseAsset, tokenOut\n 700\n );\n\n // Deploy 600 asset to DV2\n _underlyerTwo.mint(address(this), 600);\n _underlyerTwo.approve(address(_lmpVault), 600);\n _lmpVault.rebalance(\n address(_destVaultTwo),\n address(_underlyerTwo), // tokenIn\n 600,\n address(0), // destinationOut, none when sending out baseAsset\n address(_asset), // baseAsset, tokenOut\n 600\n );\n\n // Deployed 200 asset to DV3\n _underlyerThree.mint(address(this), 200);\n _underlyerThree.approve(address(_lmpVault), 200);\n _lmpVault.rebalance(\n address(_destVaultThree),\n address(_underlyerThree), // tokenIn\n 200,\n address(0), // destinationOut, none when sending out baseAsset\n address(_asset), // baseAsset, tokenOut\n 200\n );\n\n // Drop the price of DV2 to 70% of original, so that 600 we transferred out is now only worth 420\n _mockRootPrice(address(_underlyerTwo), 7e17);\n\n // Revert because of an arithmetic underflow\n vm.expectRevert();\n uint256 assets = _lmpVault.redeem(1000, address(this), address(this));\n }\n```\n | medium |
```\nEvery Pool is a standalone smart contract. It is made upgradeable with OpenZeppelin's Proxy Upgrade Pattern.\n```\n | medium |
```\nif (unstakeAmount > totalPendingUnstake) {\n pool.receiveWithoutActivation{value: unstakeAmount - totalPendingUnstake}();\n unstakeAmount = totalPendingUnstake;\n}\n\ntotalPendingUnstake -= unstakeAmount;\ntotalUnstaked += unstakeAmount;\nuint256 amountToFill = unstakeAmount;\n\nfor (uint256 i = unstakeRequestCurrentIndex; i <= unstakeRequestCount; i++) {\n UnstakeRequest storage request = \_unstakeRequests[i];\n if (amountToFill > (request.amount - request.amountFilled)) {\n amountToFill -= (request.amount - request.amountFilled);\n continue;\n } else {\n if (amountToFill == (request.amount - request.amountFilled) && i < unstakeRequestCount) {\n unstakeRequestCurrentIndex = i + 1;\n } else {\n request.amountFilled += uint128(amountToFill);\n unstakeRequestCurrentIndex = i;\n }\n break;\n }\n}\n```\n | low |
```\nfunction tryMod(\n uint256 a,\n uint256 b\n) 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\_createPermissions(\_acl, grantees, \_fundraisingApps.bondedTokenManager, \_fundraisingApps.bondedTokenManager.MINT\_ROLE(), \_owner);\n\_acl.createPermission(\_fundraisingApps.marketMaker, \_fundraisingApps.bondedTokenManager, \_fundraisingApps.bondedTokenManager.BURN\_ROLE(), \_owner);\n```\n | high |
```\n// SPDX-License-Identifier: UNLICENSED\npragma solidity 0.8.17;\n\nimport { FlashBorrower, Flashloan, IERC20Token } from "./FlashLoan.sol";\nimport { Pool } from "./../../src/Pool.sol";\n\ncontract Borrower is FlashBorrower {\n address public immutable owner;\n Flashloan public immutable flashLoan;\n Pool public immutable pool;\n IERC20Token public loanToken;\n\n constructor(Flashloan _flashLoan, Pool _pool) {\n owner = msg.sender;\n flashLoan = _flashLoan;\n pool = _pool;\n loanToken = IERC20Token(address(_pool.LOAN_TOKEN()));\n }\n\n function borrowAll() public returns (bool) {\n // Get current values from pool\n pool.withdraw(0);\n uint loanTokenBalance = loanToken.balanceOf(address(pool));\n loanToken.approve(address(pool), loanTokenBalance);\n\n // Execute flash loan\n flashLoan.execute(FlashBorrower(address(this)), loanToken, loanTokenBalance, abi.encode(loanTokenBalance));\n }\n\n function onFlashLoan(IERC20Token token, uint amount, bytes calldata data) public override {\n // Decode data\n (uint loanTokenBalance) = abi.decode(data, (uint));\n\n // Deposit tokens borrowed from flash loan, borrow all other LOAN tokens from pool and\n // withdraw the deposited tokens\n pool.deposit(amount);\n pool.borrow(loanTokenBalance);\n pool.withdraw(amount);\n\n // Repay the loan\n token.transfer(address(flashLoan), amount);\n\n // Send loan tokens to owner\n loanToken.transfer(owner, loanTokenBalance);\n }\n}\n```\n | medium |
```\nfunction getPositionValue() public view returns (uint256) {\n uint256 markPrice = getMarkPriceTwap(15);\n int256 positionSize = IAccountBalance(clearingHouse.getAccountBalance())\n .getTakerPositionSize(address(this), market);\n return markPrice.mulWadUp(_abs(positionSize));\n}\n\nfunction getMarkPriceTwap(uint32 twapInterval)\n public\n view\n returns (uint256)\n{\n IExchange exchange = IExchange(clearingHouse.getExchange());\n uint256 markPrice = exchange\n .getSqrtMarkTwapX96(market, twapInterval)\n .formatSqrtPriceX96ToPriceX96()\n .formatX96ToX10_18();\n return markPrice;\n}\n```\n | high |
```\nrefundMap[policyIndex\_][week] = incomeMap[policyIndex\_][week].mul(\n allCovered.sub(maximumToCover)).div(allCovered);\n```\n | high |
```\nfunction approvedToLog(address \_caller) public pure returns (bool) {\n /\* TODO: auth via system \*/\n \_caller;\n return true;\n}\n```\n | high |
```\nfunction setMinimumTokenBalanceForAutoDividends(uint256 value) external onlyOwner {\n minimumTokenBalanceForAutoDividends = value * (10**18);\n}\n```\n | none |
```\nFile: CurveV2Adapter.sol\n function getExecutionData(address from, Trade calldata trade)\n internal view returns (\n address spender,\n address target,\n uint256 msgValue,\n bytes memory executionCallData\n )\n {\n if (trade.tradeType == TradeType.EXACT_IN_SINGLE) {\n CurveV2SingleData memory data = abi.decode(trade.exchangeData, (CurveV2SingleData));\n executionCallData = abi.encodeWithSelector(\n ICurveRouterV2.exchange.selector,\n data.pool,\n _getTokenAddress(trade.sellToken),\n _getTokenAddress(trade.buyToken),\n trade.amount,\n trade.limit,\n address(this)\n );\n } else if (trade.tradeType == TradeType.EXACT_IN_BATCH) {\n CurveV2BatchData memory data = abi.decode(trade.exchangeData, (CurveV2BatchData));\n // Array of pools for swaps via zap contracts. This parameter is only needed for\n // Polygon meta-factories underlying swaps.\n address[4] memory pools;\n executionCallData = abi.encodeWithSelector(\n ICurveRouterV2.exchange_multiple.selector,\n data.route,\n data.swapParams,\n trade.amount,\n trade.limit,\n pools,\n address(this)\n );\n```\n | high |
```\nconstructor() {\n _transferOwnership(_msgSender());\n}\n```\n | none |
```\nconstructor () public {\n instance = new MultipleWinners();\n}\n```\n | low |
```\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return\n interfaceId == _INTERFACEID_LSP6 || interfaceId == _INTERFACEID_ERC1271 ||\n super.supportsInterface(interfaceId);\n }\n```\n | medium |
```\nfunction getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n}\n```\n | none |
```\nfunction addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {\n // approve token transfer to cover all possible scenarios\n _approve(address(this), address(uniswapV2Router), tokenAmount);\n\n // add the liquidity\n uniswapV2Router.addLiquidityETH{value: ethAmount}(\n address(this),\n tokenAmount,\n 0, // slippage is unavoidable\n 0, // slippage is unavoidable\n liquidityWallet,\n block.timestamp\n );\n}\n```\n | none |
```\nfunction setDeListingBonus(uint64 delistingBonus) external onlyOwner() {\n ListingUpdate memory update = listingUpdate;\n require(update.tokenToDelist != address(0), "DFP: No active delisting");\n\n DFPconfig.delistingBonus = delistingBonus;\n}\n```\n | none |
```\naddress owner = ownerOf(_tokenId);\nif (msg.sender != owner && !isApprovedForAll[owner][msg.sender] && msg.sender != getApproved[_tokenId]) revert NotAuthorized();\n```\n | high |
```\nfunction log256(uint256 value) internal pure returns (uint256) {\n uint256 result = 0;\n unchecked {\n if (value >> 128 > 0) {\n value >>= 128;\n result += 16;\n }\n if (value >> 64 > 0) {\n value >>= 64;\n result += 8;\n }\n if (value >> 32 > 0) {\n value >>= 32;\n result += 4;\n }\n if (value >> 16 > 0) {\n value >>= 16;\n result += 2;\n }\n if (value >> 8 > 0) {\n result += 1;\n }\n }\n return result;\n}\n```\n | none |
```\nfunction balanceOf(address account) public view override returns (uint256) {\n return tokenFromReflection(_rOwned[account]);\n}\n```\n | none |
```\nconstructor(address \_collateral, uint256 decimals) public {\n require(decimals <= MAX\_DECIMALS, "decimals out of range");\n require(\_collateral != address(0x0) || (\_collateral == address(0x0) && decimals == 18), "invalid decimals");\n\n collateral = \_collateral;\n scaler = (decimals == MAX\_DECIMALS ? 1 : 10\*\*(MAX\_DECIMALS - decimals)).toInt256();\n}\n```\n | low |
```\nfunction changeStablePair(address newStablePair, address newStableAddress)\n external\n onlyOwner\n{\n require(\n newStablePair != address(0) && newStableAddress != address(0),\n "New addresses must not be the ZERO address"\n );\n\n stablePairAddress = newStablePair;\n stableAddress = newStableAddress;\n emit StablePairChanged(newStablePair, newStableAddress);\n}\n```\n | none |
```\nfunction approve(address spender, uint256 amount)\n public\n override\n returns (bool)\n{\n _approve(_msgSender(), spender, amount);\n return true;\n}\n```\n | none |
```\n function approve(address spender, uint256 amount) public virtual returns (bool) {\n allowance[msg.sender][spender] = amount;\n\n emit Approval(msg.sender, spender, amount);\n\n return true;\n }\n```\n | medium |
```\n it("PoC: staker with locked balance gets more rewards even when just locked", async () => {\n const trustAmount = parseUnits("2000");\n const borrowAmount = parseUnits("1800");\n const [account, staker, borrower] = members;\n\n const [accountStaked, borrowerStaked, stakerStaked] = await helpers.getStakedAmounts(\n account,\n staker,\n borrower\n );\n\n expect(accountStaked).eq(borrowerStaked);\n expect(borrowerStaked).eq(stakerStaked);\n\n await helpers.updateTrust(staker, borrower, trustAmount);\n \n await roll(10);\n await helpers.borrow(borrower, borrowAmount); // borrows just after withdrawing\n \n const [accountMultiplier, stakerMultiplier] = await helpers.getRewardsMultipliers(account, staker);\n console.log("accountMultiplier: ", accountMultiplier);\n console.log("StakerMultiplier: ", stakerMultiplier);\n expect(accountMultiplier).lt(stakerMultiplier); // the multiplier is larger even if just locked\n });\n```\n | medium |
```\nfunction add(uint256 a, uint256 b) internal pure returns (uint256) {\n uint256 c = a + b;\n require(c >= a, "SafeMath: addition overflow");\n\n return c;\n}\n```\n | none |
```\nuint256 totalCollateralAmount = bid.collateralAmount + collateralAmount;\n```\n | medium |
```\nfunction toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n bytes memory buffer = new bytes(2 * length + 2);\n buffer[0] = "0";\n buffer[1] = "x";\n for (uint256 i = 2 * length + 1; i > 1; --i) {\n buffer[i] = _HEX_SYMBOLS[value & 0xf];\n value >>= 4;\n }\n require(value == 0, "Strings: hex length insufficient");\n return string(buffer);\n}\n```\n | none |
```\nfunction testBorrowOverflow() public {\n uint256 borrowAmount = 1e40;\n BorrowArg[] memory borrowArgs = new BorrowArg[](1);\n (, ,uint256 loanId , ) = kairos.getParameters();\n loanId += 1;\n\n Offer memory offer = Offer({\n assetToLend: money,\n loanToValue: 1e61,\n duration: 1,\n expirationDate: block.timestamp + 2 hours,\n tranche: 0,\n collateral: getNft()\n });\n uint256 currentTokenId;\n\n getFlooz(signer, money, getOfferArg(offer).amount);\n\n {\n OfferArg[] memory offerArgs = new OfferArg[](1);\n currentTokenId = getJpeg(BORROWER, nft);\n offer.collateral.id = currentTokenId;\n offerArgs[0] = OfferArg({\n signature: getSignature(offer),\n amount: borrowAmount,\n offer: offer\n });\n borrowArgs[0] = BorrowArg({nft: NFToken({id: currentTokenId, implem: nft}), args: offerArgs});\n }\n\n vm.prank(BORROWER);\n kairos.borrow(borrowArgs);\n\n assertEq(nft.balanceOf(BORROWER), 0);\n assertEq(money.balanceOf(BORROWER), borrowAmount);\n assertEq(nft.balanceOf(address(kairos)), 1);\n\n vm.warp(block.timestamp + 1);\n Loan memory loan = kairos.getLoan(loanId);\n console.log("price of loanId", kairos.price(loanId));\n}\n```\n | medium |
```\nuint256 timeSinceMigration = finalMigrationTime - lastClaimTime;\n\n// (timeSinceMigration \* INTERNAL\_TOKEN\_PRECISION \* finalEmissionRatePerYear) / YEAR\nuint256 incentiveRate =\n timeSinceMigration\n .mul(uint256(Constants.INTERNAL\_TOKEN\_PRECISION))\n // Migration emission rate is stored as is, denominated in whole tokens\n .mul(finalEmissionRatePerYear).mul(uint256(Constants.INTERNAL\_TOKEN\_PRECISION))\n .div(Constants.YEAR);\n\n// Returns the average supply using the integral of the total supply.\nuint256 avgTotalSupply = finalTotalIntegralSupply.sub(lastClaimIntegralSupply).div(timeSinceMigration);\n```\n | medium |
```\nconstructor() Auth(msg.sender) {\n weth = IUniswapV2Router02(router).WETH();\n fee = ecosystemFee + marketingFee + treasuryFee;\n\n isFeeExempt[msg.sender] = true;\n\n balanceOf[msg.sender] = totalSupply;\n emit Transfer(address(0), msg.sender, totalSupply);\n}\n```\n | none |
```\nfunction \_hashLeaf(uint32 user\_id, uint256 user\_amount, bytes32 leaf) private returns (bool) {\n```\n | low |
```\nFile: contracts\WooPPV2.sol\n function _swapBaseToBase(\n// rest of code\n ) private nonReentrant whenNotPaused returns (uint256 base2Amount) {\n require(baseToken1 != address(0) && baseToken1 != quoteToken, "WooPPV2: !baseToken1");\n require(baseToken2 != address(0) && baseToken2 != quoteToken, "WooPPV2: !baseToken2");\n// rest of code\n IWooracleV2.State memory state1 = IWooracleV2(wooracle).state(baseToken1);\n IWooracleV2.State memory state2 = IWooracleV2(wooracle).state(baseToken2);\n// rest of code\n uint256 newBase1Price;\n (quoteAmount, newBase1Price) = _calcQuoteAmountSellBase(baseToken1, base1Amount, state1);\n IWooracleV2(wooracle).postPrice(baseToken1, uint128(newBase1Price));\n// rest of code\n uint256 newBase2Price;\n (base2Amount, newBase2Price) = _calcBaseAmountSellQuote(baseToken2, quoteAmount, state2);\n IWooracleV2(wooracle).postPrice(baseToken2, uint128(newBase2Price));\n// rest of code\n }\n```\n | medium |
```\nfunction add(uint256 a, uint256 b) internal pure returns (uint256) {\n uint256 c = a + b;\n require(c >= a, "SafeMath: addition overflow");\n\n return c;\n}\n```\n | none |
```\n function cancel() external onlyPayerOrRecipient {\n address payer_ = payer();\n address recipient_ = recipient();\n IERC20 token_ = token();\n\n uint256 recipientBalance = balanceOf(recipient_);\n\n // This zeroing is important because without it, it's possible for recipient to obtain additional funds\n // from this contract if anyone (e.g. payer) sends it tokens after cancellation.\n // Thanks to this state update, `balanceOf(recipient_)` will only return zero in future calls.\n remainingBalance = 0;\n\n if (recipientBalance > 0) token_.safeTransfer(recipient_, recipientBalance);\n```\n | medium |
```\nfunction cancelControlTransfer(address split)\n external\n override\n onlySplitController(split)\n{\n delete splits[split].newPotentialController;\n emit CancelControlTransfer(split);\n}\n```\n | none |
```\nfunction tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n // benefit is lost if 'b' is also tested.\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n if (a == 0) return (true, 0);\n uint256 c = a * b;\n if (c / a != b) return (false, 0);\n return (true, c);\n }\n}\n```\n | none |
```\ncontract ZeroDAOToken is\n OwnableUpgradeable,\n ERC20Upgradeable,\n ERC20PausableUpgradeable,\n ERC20SnapshotUpgradeable\n{\n```\n | high |
```\nfunction totalFunds() public view override returns (uint256, uint256) {\n return ConvexPositionHandler.positionInWantToken();\n}\n```\n | high |
```\nfunction _calculateMaxBorrowCollateral(ActionInfo memory _actionInfo, bool _isLever) internal view returns(uint256) {\n \n // Retrieve collateral factor and liquidation threshold for the collateral asset in precise units (1e16 = 1%)\n ( , uint256 maxLtvRaw, uint256 liquidationThresholdRaw, , , , , , ,) = strategy.aaveProtocolDataProvider.getReserveConfigurationData(address(strategy.collateralAsset));\n\n // Normalize LTV and liquidation threshold to precise units. LTV is measured in 4 decimals in Aave which is why we must multiply by 1e14\n // for example ETH has an LTV value of 8000 which represents 80%\n if (_isLever) {\n uint256 netBorrowLimit = _actionInfo.collateralValue\n .preciseMul(maxLtvRaw.mul(10 ** 14))\n .preciseMul(PreciseUnitMath.preciseUnit().sub(execution.unutilizedLeveragePercentage));\n\n return netBorrowLimit\n .sub(_actionInfo.borrowValue)\n .preciseDiv(_actionInfo.collateralPrice);\n```\n | high |
```\nuint256 liquidatableAmount = totalPositionSize.sub(totalPositionSize.mod(governance.lotSize));\nliquidationAmount = liquidationAmount.ceil(governance.lotSize).min(maxAmount).min(liquidatableAmount);\n```\n | medium |
```\nfunction getPurchasedAmount(address holder) public returns (uint amount) {\n // check if any delegation was ended\n for (uint i = 0; i < \_endingDelegations[holder].length; ++i) {\n getState(\_endingDelegations[holder][i]);\n }\n return \_purchased[holder];\n```\n | medium |
```\n(uint80 roundID, int256 price,, uint256 updatedAt, uint80 answeredInRound) = priceFeed.latestRoundData();\nrequire(price > 0, "Chainlink: Incorrect Price");\nrequire(block.timestamp - updatedAt < priceSources[token].heartBeat, "Chainlink: Stale Price");\nrequire(answeredInRound >= roundID, "Chainlink: Stale Price");\n```\n | medium |
```\nfunction _reflectFee(uint256 rFee, uint256 tFee) private {\n _rTotal = _rTotal.sub(rFee);\n _tFeeTotal = _tFeeTotal.add(tFee);\n}\n```\n | none |
```\nfunction getUserOpHash(UserOperation calldata userOp) public view returns (bytes32) {\n return keccak256(abi.encode(userOp.hash(), address(this), block.chainid));\n}\n```\n | none |
```\nfunction acceptBid(bytes memory signature, uint256 rand, address bidder, uint256 bid, address nftaddress, uint256 tokenid) external {\n address recoveredbidder = recover(toEthSignedMessageHash(keccak256(abi.encode(rand, address(this), block.chainid, bid, nftaddress, tokenid))), signature);\n require(bidder == recoveredbidder, 'zAuction: incorrect bidder');\n require(!randUsed[rand], 'Random nonce already used');\n randUsed[rand] = true;\n IERC721 nftcontract = IERC721(nftaddress);\n accountant.Exchange(bidder, msg.sender, bid);\n nftcontract.transferFrom(msg.sender, bidder, tokenid);\n emit BidAccepted(bidder, msg.sender, bid, nftaddress, tokenid);\n}\n```\n | high |
```\nTRANSFER_PROXY.tokenTransferFrom(WETH, payer, payee, paymentAmount);\n```\n | medium |
```\nfunction div(uint256 a, uint256 b) internal pure returns (uint256) {\n return a / b;\n}\n```\n | none |
```\n mapping(address => address) public nativeToBridgedToken;\n mapping(address => address) public bridgedToNativeToken;\n```\n | high |
```\nstruct Deposit {\n\n // SET DURING CONSTRUCTION\n address TBTCSystem;\n address TBTCToken;\n address TBTCDepositToken;\n address FeeRebateToken;\n address VendingMachine;\n uint256 lotSizeSatoshis;\n uint8 currentState;\n uint256 signerFeeDivisor;\n uint128 undercollateralizedThresholdPercent;\n uint128 severelyUndercollateralizedThresholdPercent;\n```\n | low |
```\nFile: ProtectionPool.sol\n\n /// step 1: Capture protection pool's current investors by creating a snapshot of the token balance by using ERC20Snapshot in SToken\n _snapshotId = _snapshot();\n```\n | medium |
```\nif (operatorFee > 0) {\n (status, data) = operator.call{value: operatorFee}("");\n if (status == false) {\n revert FeeRecipientReceiveError(data);\n }\n}\n```\n | medium |
```\nfunction _reinvestDividendOfUser(address account) private returns (uint256) {\n uint256 _withdrawableDividend = withdrawableDividendOf(account);\n if (_withdrawableDividend > 0) {\n bool success;\n\n withdrawnDividends[account] = withdrawnDividends[account].add(_withdrawableDividend);\n\n address[] memory path = new address[](2);\n path[0] = uniswapV2Router.WETH();\n path[1] = address(VenomContract);\n\n uint256 prevBalance = VenomContract.balanceOf(address(this));\n\n // make the swap\n try\n uniswapV2Router\n .swapExactETHForTokensSupportingFeeOnTransferTokens{value: _withdrawableDividend}\n (0, path, address(this), block.timestamp)\n {\n uint256 received = VenomContract.balanceOf(address(this)).sub(prevBalance);\n if (received > 0) {\n success = true;\n VenomContract.transfer(account, received);\n } \n else {\n success = false;\n }\n } catch {\n success = false;\n }\n\n if (!success) {\n withdrawnDividends[account] = withdrawnDividends[account].sub(_withdrawableDividend);\n return 0;\n }\n\n return _withdrawableDividend;\n }\n\n return 0;\n}\n```\n | none |
```\n function getReservedUsd(\n DataStore dataStore,\n Market.Props memory market,\n MarketPrices memory prices,\n bool isLong\n ) internal view returns (uint256) {\n uint256 reservedUsd;\n if (isLong) {\n // for longs calculate the reserved USD based on the open interest and current indexTokenPrice\n // this works well for e.g. an ETH / USD market with long collateral token as WETH\n // the available amount to be reserved would scale with the price of ETH\n // this also works for e.g. a SOL / USD market with long collateral token as WETH\n // if the price of SOL increases more than the price of ETH, additional amounts would be\n // automatically reserved\n uint256 openInterestInTokens = getOpenInterestInTokens(dataStore, market, isLong);\n reservedUsd = openInterestInTokens * prices.indexTokenPrice.max;\n } else {\n // for shorts use the open interest as the reserved USD value\n // this works well for e.g. an ETH / USD market with short collateral token as USDC\n // the available amount to be reserved would not change with the price of ETH\n reservedUsd = getOpenInterest(dataStore, market, isLong);\n }\n\n return reservedUsd;\n }\n```\n | medium |
```\n// Make sure we can actually buy the resource amount requested by the user.\nparams.prevBoughtGas += _amount;\nrequire(\n int256(uint256(params.prevBoughtGas)) <= MAX_RESOURCE_LIMIT,\n "ResourceMetering: cannot buy more gas than available gas limit"\n);\n```\n | medium |
```\nfunction swapBack() private {\n uint256 contractBalance = balanceOf(address(this));\n uint256 totalTokensToSwap = tokensForLiquidity + tokensForMarketing + tokensForDev;\n bool success;\n\n if(contractBalance == 0 || totalTokensToSwap == 0) {return;}\n\n if(contractBalance > swapTokensAtAmount * 20){\n contractBalance = swapTokensAtAmount * 20;\n }\n\n uint256 liquidityTokens = contractBalance * tokensForLiquidity / totalTokensToSwap / 2;\n uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);\n\n uint256 initialETHBalance = address(this).balance;\n\n swapTokensForEth(amountToSwapForETH); \n\n uint256 ethBalance = address(this).balance.sub(initialETHBalance);\n\n uint256 ethForMarketing = ethBalance.mul(tokensForMarketing).div(totalTokensToSwap);\n uint256 ethForDev = ethBalance.mul(tokensForDev).div(totalTokensToSwap);\n\n\n uint256 ethForLiquidity = ethBalance - ethForMarketing - ethForDev;\n\n\n tokensForLiquidity = 0;\n tokensForMarketing = 0;\n tokensForDev = 0;\n\n (success,) = address(devWallet).call{value: ethForDev}("");\n\n if(liquidityTokens > 0 && ethForLiquidity > 0){\n addLiquidity(liquidityTokens, ethForLiquidity);\n emit SwapAndLiquify(amountToSwapForETH, ethForLiquidity, tokensForLiquidity);\n }\n\n\n (success,) = address(marketingWallet).call{value: address(this).balance}("");\n}\n```\n | none |
```\n if (block.number <= lastRepay + overdueBlocks + maxOverdueBlocks) {\n if (staker != msg.sender) revert AuthFailed();\n }\n```\n | high |
```\nfunction sendETHToFee(uint256 amount) private {\n _feeAddrWallet1.transfer(amount.div(2));\n _feeAddrWallet2.transfer(amount.div(2));\n}\n```\n | none |
```\nfunction transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {\n _transfer(sender, recipient, amount);\n _approve(sender, _msgSender(), _allowances[sender][_msgSender()] - amount);\n return true;\n}\n```\n | none |
```\nfunction getOraclePrice(IAggregatorV3 _priceFeed, int192 _maxPrice, int192 _minPrice) public view returns (uint256 ) {\n (\n /*uint80 roundID*/,\n int signedPrice,\n /*uint startedAt*/,\n uint timeStamp,\n /*uint80 answeredInRound*/\n ) = _priceFeed.latestRoundData();\n //check for Chainlink oracle deviancies, force a revert if any are present. Helps prevent a LUNA like issue\n require(signedPrice > 0, "Negative Oracle Price");\n require(timeStamp >= block.timestamp - HEARTBEAT_TIME , "Stale pricefeed");\n\n //@audit revert if price is outside of immutable bounds\n require(signedPrice < _maxPrice, "Upper price bound breached");\n require(signedPrice > _minPrice, "Lower price bound breached");\n uint256 price = uint256(signedPrice);\n return price;\n}\n```\n | medium |
```\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 liquidation(address provider, address onBehalfOf, uint256 assetAmount) external virtual {\n uint256 assetPrice = getAssetPrice();\n uint256 onBehalfOfCollateralRatio = (depositedAsset[onBehalfOf] \* assetPrice \* 100) / borrowed[onBehalfOf];\n require(onBehalfOfCollateralRatio < badCollateralRatio, "Borrowers collateral ratio should below badCollateralRatio");\n\n require(assetAmount \* 2 <= depositedAsset[onBehalfOf], "a max of 50% collateral can be liquidated");\n require(EUSD.allowance(provider, address(this)) != 0, "provider should authorize to provide liquidation EUSD");\n uint256 eusdAmount = (assetAmount \* assetPrice) / 1e18;\n\n \_repay(provider, onBehalfOf, eusdAmount);\n uint256 reducedAsset = assetAmount \* 11 / 10;\n totalDepositedAsset -= reducedAsset;\n depositedAsset[onBehalfOf] -= reducedAsset;\n uint256 reward2keeper;\n if (provider == msg.sender) {\n collateralAsset.safeTransfer(msg.sender, reducedAsset);\n } else {\n reward2keeper = (reducedAsset \* configurator.vaultKeeperRatio(address(this))) / 110;\n collateralAsset.safeTransfer(provider, reducedAsset - reward2keeper);\n collateralAsset.safeTransfer(msg.sender, reward2keeper);\n }\n emit LiquidationRecord(provider, msg.sender, onBehalfOf, eusdAmount, reducedAsset, reward2keeper, false, block.timestamp);\n}\n```\n | medium |
```\nFile: BondBaseCallback.sol\n /* ========== WHITELISTING ========== */\n\n /// @inheritdoc IBondCallback\n function whitelist(address teller_, uint256 id_) external override onlyOwner {\n // Check that the market id is a valid, live market on the aggregator\n try _aggregator.isLive(id_) returns (bool live) {\n if (!live) revert Callback_MarketNotSupported(id_);\n } catch {\n revert Callback_MarketNotSupported(id_);\n }\n\n // Check that the provided teller is the teller for the market ID on the stored aggregator\n // We could pull the teller from the aggregator, but requiring the teller to be passed in\n // is more explicit about which contract is being whitelisted\n if (teller_ != address(_aggregator.getTeller(id_))) revert Callback_TellerMismatch();\n\n approvedMarkets[teller_][id_] = true;\n }\n```\n | medium |
```\nfunction test_DeleteBridgeWithAssets() public {\n console.log("Sender ethEscrowed in vault 2 before deposit: ", diamond.getVaultUserStruct(2, sender).ethEscrowed);\n deal(_rethA, sender, 10000 ether);\n\n vm.startPrank(sender);\n uint88 deposit1 = 1000 ether;\n uint88 withdrawAmount = 100 ether;\n diamond.deposit(_bridgeRethToBeDeleted, deposit1);\n console.log("Sender ethEscrowed in vault2 after deposit: ", diamond.getVaultUserStruct(2, sender).ethEscrowed);\n diamond.withdraw(_bridgeRethToBeDeleted, withdrawAmount);\n console.log("Sender ethEscrowed after withdraw: ", diamond.getVaultUserStruct(2, sender).ethEscrowed);\n vm.stopPrank();\n\n console.log("Balance of reth in the bridgeRethToBeDeleted: ", rethA.balanceOf(_bridgeRethToBeDeleted));\n\n /// INFO: DAO deletes the bridge after a vote has been passed\n vm.startPrank(owner) ;\n diamond.deleteBridge(_bridgeRethToBeDeleted);\n vm.stopPrank();\n\n vm.startPrank(sender);\n vm.expectRevert();\n diamond.withdraw(_bridgeRethToBeDeleted, withdrawAmount);\n console.log("Balance of reth in the bridgeRethToBeDeleted: ", rethA.balanceOf(_bridgeRethToBeDeleted));\n vm.stopPrank();\n }\n```\n | low |
```\n function mintViaUnderlying(\n uint256 depositAmountExternal,\n uint88 fCashAmount,\n address receiver,\n uint32 minImpliedRate//@audit when lendAmount bigger than maxFCash lack of minRate protect.\n ) external override {\n (/* */, uint256 maxFCash) = getTotalFCashAvailable();\n _mintInternal(depositAmountExternal, fCashAmount, receiver, minImpliedRate, maxFCash);\n }\n```\n | high |
```\nIERC20(vaultWantToken()).approve(vault, MAX\_INT);\n```\n | low |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.