function
stringlengths 12
63.3k
| severity
stringclasses 4
values |
|---|---|
```\n function blacklistProtocol(uint256 _protocolNum) external onlyGuardian {\n uint256 balanceProtocol = balanceUnderlying(_protocolNum);\n currentAllocations[_protocolNum] = 0;\n controller.setProtocolBlacklist(vaultNumber, _protocolNum);\n savedTotalUnderlying -= balanceProtocol;\n withdrawFromProtocol(_protocolNum, balanceProtocol);\n }\n```\n | medium |
```\nFile: BalancerComposableAuraVault.sol\n function _checkPriceAndCalculateValue() internal view override returns (uint256) {\n (uint256[] memory balances, uint256[] memory spotPrices) = SPOT_PRICE.getComposableSpotPrices(\n BALANCER_POOL_ID,\n address(BALANCER_POOL_TOKEN),\n PRIMARY_INDEX()\n );\n\n // Spot prices are returned in native decimals, convert them all to POOL_PRECISION\n // as required in the _calculateLPTokenValue method.\n (/* */, uint8[] memory decimals) = TOKENS();\n for (uint256 i; i < spotPrices.length; i++) {\n spotPrices[i] = spotPrices[i] * POOL_PRECISION() / 10 ** decimals[i];\n }\n\n return _calculateLPTokenValue(balances, spotPrices);\n }\n```\n | high |
```\nbUsdo.executeModule(\n IUsdo.Module.UsdoMarketReceiver, \n abi.encodeWithSelector(\n UsdoMarketReceiverModule.removeAssetReceiver.selector, \n marketMsg_), \n false);\n```\n | high |
```\nfunction checkWhitelist(address _wallet) external view returns (bool) {\n return whitelisted[_wallet];\n}\n```\n | none |
```\nif (nextBoxNumber > 1 && nextBoxNumber > nextExecuteBoxNumber) {\n```\n | low |
```\nfunction updatemarketingWallet (address newWallet) external onlyOwner{\n emit marketingWalletUpdated(newWallet,marketingWallet);\n marketingWallet = newWallet;\n}\n```\n | none |
```\n function _mintInternal(address _receiver, uint _balanceIncreased, uint _totalAsset\n ) internal returns (uint mintShares) {\n unfreezeTime[_receiver] = block.timestamp + mintFreezeInterval;\n if (freezeBuckets.interval > 0) {\n FreezeBuckets.addToFreezeBuckets(freezeBuckets, _balanceIncreased.toUint96());\n }\n uint _totalSupply = totalSupply();\n if (_totalAsset == 0 || _totalSupply == 0) {\n mintShares = _balanceIncreased + _totalAsset;\n } else {\n mintShares = (_balanceIncreased * _totalSupply) / _totalAsset;\n }\n if (mintShares == 0) {\n revert ZeroAmount();\n }\n _mint(_receiver, mintShares);\n }\n```\n | high |
```\nfunction approve(address spender, uint amount) external override returns (bool) {\n allowance[msg.sender][spender] = amount;\n emit Approval(msg.sender, spender, amount);\n return true;\n}\n```\n | none |
```\nfunction withdrawTo(address payable withdrawAddress, uint256 withdrawAmount) external {\n DepositInfo storage info = deposits[msg.sender];\n require(withdrawAmount <= info.deposit, "Withdraw amount too large");\n info.deposit = uint112(info.deposit - withdrawAmount);\n emit Withdrawn(msg.sender, withdrawAddress, withdrawAmount);\n (bool success,) = withdrawAddress.call{value : withdrawAmount}("");\n require(success, "failed to withdraw");\n}\n```\n | none |
```\nfunction sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, "Address: insufficient balance");\n\n (bool success, ) = recipient.call{value: amount}("");\n require(success, "Address: unable to send value, recipient may have reverted");\n}\n```\n | none |
```\n function setLenderManager(address _lenderManager)\n external\n reinitializer(8)\n onlyOwner\n {\n _setLenderManager(_lenderManager);\n }\n\n function _setLenderManager(address _lenderManager)\n internal\n onlyInitializing\n {\n require(\n _lenderManager.isContract(),\n "LenderManager must be a contract"\n );\n lenderManager = ILenderManager(_lenderManager);\n }\n```\n | medium |
```\nmodifier onlySource(address _originSender, uint32 _origin) {\n require(_originSender == trustedRemoteConnext[_origin] && msg.sender == connext, "Not trusted");\n _;\n}\n```\n | high |
```\nif (\n !context.currentPosition.local.margined(context.latestVersion, context.riskParameter, context.pendingCollateral)\n) revert MarketInsufficientMarginError();\n```\n | medium |
```\n function shutdownMarket(address asset)\n external\n onlyValidAsset(asset)\n isNotFrozen(asset)\n nonReentrant\n {\n uint256 cRatio = _getAssetCollateralRatio(asset);\n if (cRatio > LibAsset.minimumCR(asset)) {\n revert Errors.SufficientCollateral();\n } else {\n STypes.Asset storage Asset = s.asset[asset];\n uint256 vault = Asset.vault;\n uint88 assetZethCollateral = Asset.zethCollateral;\n s.vault[vault].zethCollateral -= assetZethCollateral;\n Asset.frozen = F.Permanent;\n if (cRatio > 1 ether) {\n // More than enough collateral to redeem ERC 1:1, send extras to TAPP\n uint88 excessZeth =\n assetZethCollateral - assetZethCollateral.divU88(cRatio);\n s.vaultUser[vault][address(this)].ethEscrowed += excessZeth;\n // Reduces c-ratio to 1\n Asset.zethCollateral -= excessZeth;\n }\n }\n emit Events.ShutdownMarket(asset);\n }\n\n // rest of code\n\n function _getAssetCollateralRatio(address asset)\n private\n view\n returns (uint256 cRatio)\n {\n STypes.Asset storage Asset = s.asset[asset];\n return Asset.zethCollateral.div(LibOracle.getPrice(asset).mul(Asset.ercDebt));\n }\n```\n | medium |
```\nfunction \_setPeriod(uint64 \_period) internal {\n require(\_period > 0, ERROR\_TIME\_PERIOD\_ZERO);\n require(openDate == 0 || openDate + \_period > getTimestamp64(), ERROR\_INVALID\_TIME\_PERIOD);\n period = \_period;\n}\n```\n | medium |
```\n function setTierWinner(\n string calldata _bountyId,\n uint256 _tier,\n string calldata _winner\n ) external {\n IBounty bounty = getBounty(_bountyId);\n require(msg.sender == bounty.issuer(), Errors.CALLER_NOT_ISSUER);\n bounty.setTierWinner(_winner, _tier);\n\n emit TierWinnerSelected(\n address(bounty),\n bounty.getTierWinners(),\n new bytes(0),\n VERSION_1\n );\n }\n\n function setTierWinner(string memory _winner, uint256 _tier)\n external\n onlyOpenQ\n {\n tierWinners[_tier] = _winner;\n }\n```\n | medium |
```\nfunction _verifyLendingPoolIsActive(\n IDefaultStateManager defaultStateManager,\n address _protectionPoolAddress,\n address _lendingPoolAddress\n ) internal view {\n LendingPoolStatus poolStatus = defaultStateManager.getLendingPoolStatus(\n _protectionPoolAddress,\n _lendingPoolAddress\n );\n\n // rest of code\n if (\n poolStatus == LendingPoolStatus.LateWithinGracePeriod ||\n poolStatus == LendingPoolStatus.Late\n ) {\n revert IProtectionPool.LendingPoolHasLatePayment(_lendingPoolAddress);\n }\n // rest of code\n}\n```\n | high |
```\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 _sell(\n uint256 tokenAmount,\n uint256 deadline,\n uint256 minBNBOut\n) public nonReentrant returns (bool) {\n // deadline requirement\n require(deadline >= block.timestamp, "Deadline EXPIRED");\n\n //Frontrun Guard\n require(\n _lastBuyBlock[msg.sender] != block.number,\n "Buying and selling in the same block is not allowed!"\n );\n\n address seller = msg.sender;\n\n // make sure seller has this balance\n require(\n _balances[seller] >= tokenAmount,\n "cannot sell above token amount"\n );\n\n // get how much beans are the tokens worth\n uint256 amountBNB = liquidity -\n (liqConst / (_balances[address(this)] + tokenAmount));\n uint256 amountTax = (amountBNB * (DIVISOR - sellMul)) / DIVISOR;\n uint256 BNBToSend = amountBNB - amountTax;\n\n //slippage revert\n require(amountBNB >= minBNBOut, "INSUFFICIENT OUTPUT AMOUNT");\n\n // send BNB to Seller\n (bool successful, ) = isFeeExempt[msg.sender]\n ? payable(seller).call{value: amountBNB}("")\n : payable(seller).call{value: BNBToSend}("");\n require(successful, "BNB/ETH transfer failed");\n\n // subtract full amount from sender\n _balances[seller] = _balances[seller] - tokenAmount;\n\n //add tax allowance to be withdrawn and remove from liq the amount of beans taken by the seller\n taxBalance = isFeeExempt[msg.sender]\n ? taxBalance\n : taxBalance + amountTax;\n liquidity = liquidity - amountBNB;\n\n // add tokens back into the contract\n _balances[address(this)] = _balances[address(this)] + tokenAmount;\n\n //update volume\n uint256 cTime = block.timestamp;\n uint256 dollarSell = amountBNB * getBNBPrice();\n totalVolume += dollarSell;\n indVol[msg.sender] += dollarSell;\n tVol[cTime] += dollarSell;\n\n //update candleStickData\n totalTx += 1;\n txTimeStamp[totalTx] = cTime;\n uint256 cPrice = calculatePrice() * getBNBPrice();\n candleStickData[cTime].time = cTime;\n if (candleStickData[cTime].open == 0) {\n candleStickData[cTime].open = candleStickData[\n txTimeStamp[totalTx - 1]\n ].close;\n }\n candleStickData[cTime].close = cPrice;\n\n if (\n candleStickData[cTime].high < cPrice ||\n candleStickData[cTime].high == 0\n ) {\n candleStickData[cTime].high = cPrice;\n }\n\n if (\n candleStickData[cTime].low > cPrice ||\n candleStickData[cTime].low == 0\n ) {\n candleStickData[cTime].low = cPrice;\n }\n\n // emit transfer and sell events\n emit Transfer(seller, address(this), tokenAmount);\n if (isFeeExempt[msg.sender]) {\n emit Sold(\n address(this),\n msg.sender,\n tokenAmount,\n amountBNB,\n dollarSell\n );\n } else {\n emit Sold(\n address(this),\n msg.sender,\n tokenAmount,\n BNBToSend,\n BNBToSend * getBNBPrice()\n );\n }\n return true;\n}\n```\n | none |
```\n function executeWithdraw(address from, address to, bool isInternal, bytes memory param) external nonReentrant {\n Funding.executeWithdraw(state, from, to, isInternal, param);\n }\n```\n | high |
```\n function setIntervals(uint256 id_, uint32[3] calldata intervals_) external override {\n // Check that the market is live\n if (!isLive(id_)) revert Auctioneer_InvalidParams();\n\n\n // Check that the intervals are non-zero\n if (intervals_[0] == 0 || intervals_[1] == 0 || intervals_[2] == 0)\n revert Auctioneer_InvalidParams();\n\n\n // Check that tuneInterval >= tuneAdjustmentDelay\n if (intervals_[0] < intervals_[1]) revert Auctioneer_InvalidParams();\n\n\n BondMetadata storage meta = metadata[id_];\n // Check that tuneInterval >= depositInterval\n if (intervals_[0] < meta.depositInterval) revert Auctioneer_InvalidParams();\n\n\n // Check that debtDecayInterval >= minDebtDecayInterval\n if (intervals_[2] < minDebtDecayInterval) revert Auctioneer_InvalidParams();\n\n\n // Check that sender is market owner\n BondMarket memory market = markets[id_];\n if (msg.sender != market.owner) revert Auctioneer_OnlyMarketOwner();\n\n\n // Update intervals\n meta.tuneInterval = intervals_[0];\n meta.tuneIntervalCapacity = market.capacity.mulDiv(\n uint256(intervals_[0]),\n uint256(terms[id_].conclusion) - block.timestamp\n ); // don't have a stored value for market duration, this will update tuneIntervalCapacity based on time remaining\n meta.tuneAdjustmentDelay = intervals_[1];\n meta.debtDecayInterval = intervals_[2];\n }\n```\n | medium |
```\n borrowing.feesOwed += entranceFee;\n```\n | medium |
```\n if (SignedMath.abs(tokensToSwap) > params.sideTokensAmount) {\n if (SignedMath.abs(tokensToSwap) - params.sideTokensAmount < params.sideTokensAmount / 10000) {\n tokensToSwap = SignedMath.revabs(params.sideTokensAmount, true);\n }\n }\n```\n | medium |
```\n _doCutRewardsFee(sellToken);\n if (\n expectedRewards[i] != 0 &&\n !PSwapLib.swap(\n augustusSwapper,\n tokenTransferProxy,\n sellToken,\n expectedRewards[i],\n swapDatas[i]\n )\n ) revert Errors.SWAP_FAILED(sellToken);\n```\n | medium |
```\nfunction latestRoundData(\n address base,\n address quote\n)\n external\n view\n override\n checkPairAccess()\n returns (\n uint80 roundId,\n int256 answer,\n uint256 startedAt,\n uint256 updatedAt,\n uint80 answeredInRound\n )\n{\n uint16 currentPhaseId = s_currentPhaseId[base][quote];\n AggregatorV2V3Interface aggregator = _getFeed(base, quote);\n require(address(aggregator) != address(0), "Feed not found");\n (\n roundId,\n answer,\n startedAt,\n updatedAt,\n answeredInRound\n ) = aggregator.latestRoundData();\n return _addPhaseIds(roundId, answer, startedAt, updatedAt, answeredInRound, currentPhaseId);\n}\n```\n | medium |
```\nFile: GenericToken.sol\n function executeLowLevelCall(\n address target,\n uint256 msgValue,\n bytes memory callData\n ) internal {\n (bool status, bytes memory returnData) = target.call{value: msgValue}(callData);\n require(status, checkRevertMessage(returnData));\n }\n```\n | medium |
```\nif (\n operators.value[\_operatorIndex].limit < \_limit &&\n StakingContractStorageLib.getLastValidatorEdit() > \_snapshot\n) {\n revert LastEditAfterSnapshot();\n}\n```\n | medium |
```\n if (depositAssets.gt(_maxDeposit(context)))\n revert VaultDepositLimitExceededError();\n// rest of code\nfunction _maxDeposit(Context memory context) private view returns (UFixed6) {\n if (context.latestCheckpoint.unhealthy()) return UFixed6Lib.ZERO;\n UFixed6 collateral = UFixed6Lib.from(totalAssets().max(Fixed6Lib.ZERO)).add(context.global.deposit);\n return context.global.assets.add(context.parameter.cap.sub(collateral.min(context.parameter.cap)));\n}\n```\n | medium |
```\nassert(msg.sender == address(WETH)); // only accept ETH via fallback from the WETH contract\n```\n | low |
```\n uint inputTotalUSDValueE36;\n for (uint i; i < openTokenInfos.length; ) {\n inputTotalUSDValueE36 += openTokenInfos[i].inputAmt * tokenPriceE36s[i];\n borrowTotalUSDValueE36 += openTokenInfos[i].borrowAmt * tokenPriceE36s[i];\n unchecked {\n ++i;\n }\n }\n // 1.3 calculate net pnl (including strategy users & borrow profit)\n positionOpenUSDValueE36 = inputTotalUSDValueE36 + borrowTotalUSDValueE36;\n netPnLE36 = positionCurUSDValueE36.toInt256() - positionOpenUSDValueE36.toInt256();\n```\n | high |
```\n function collateralFactor() public view override returns (uint256) {\n uint256 totalAssetsUSD = 0;\n for (uint256 i = 0; i < collateral.length; i++) {\n totalAssetsUSD +=\n (((IERC20Upgradeable(collateral[i].token).balanceOf(\n address(this)\n ) * 1e18) /\n (10 **\n IERC20MetadataUpgradeable(collateral[i].token)\n .decimals())) *\n collateral[i].oracle.getPriceUSD()) /\n 1e18;\n }\n\n return (totalAssetsUSD * 1e6) / totalSupply();\n }\n```\n | medium |
```\nif (address(quote.sellToken) != ETH) _transferFrom(permit, stake, stakeSize);\n if (address(quote.sellToken) != stake) _fillQuote(quote);\n```\n | medium |
```\nfunction setManager(IPodManager newManager)\n public\n virtual\n onlyOwner\n returns (bool)\n{\n // Require Valid Address\n require(address(manager) != address(0), "Pod:invalid-manager-address");\n```\n | low |
```\nfunction 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}("");\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 | high |
```\nfunction lock(\n uint128 lockId,\n address tokenAddress,\n bytes32 recipient,\n bytes4 destination,\n uint256 amount\n) external isActive {\n (uint256 amountToLock, uint256 fee, TokenInfo memory tokenInfo) = _createLock(\n lockId,\n tokenAddress,\n amount,\n recipient,\n destination\n );\n\n require(tokenInfo.tokenStatus == TokenStatus.Enabled, "Bridge: disabled token");\n\n if (tokenInfo.tokenType == TokenType.Native) {\n // If token is native - transfer tokens from user to contract\n IERC20(tokenAddress).safeTransferFrom(\n msg.sender,\n address(this),\n amountToLock\n );\n } else if (tokenInfo.tokenType == TokenType.Wrapped) {\n // If wrapped then butn the token\n WrappedToken(tokenAddress).burn(msg.sender, amountToLock);\n } else if (tokenInfo.tokenType == TokenType.WrappedV0) {\n // Legacy wrapped tokens burn\n IWrappedTokenV0(tokenAddress).burn(msg.sender, amountToLock);\n } else {\n revert("Bridge: invalid token type");\n }\n\n if (fee > 0) {\n // If there is fee - transfer it to fee collector address\n IERC20(tokenAddress).safeTransferFrom(\n msg.sender,\n feeCollector,\n fee\n );\n }\n}\n```\n | none |
```\n penalty: 1 94536959275 94536000000\n penalty: 2 95482328867 95481360000\n penalty: 3 96437152156 96436173600\n penalty: 4 97401523678 97400535336\n penalty: 5 98375538914 98374540689\n penalty: 6 99359294302 99358286095\n penalty: 7 100352887244 100351868955\n penalty: 8 101356416116 101355387644\n penalty: 9 102369980277 102368941520\n penalty: 10 103393680080 103392630935\n // rest of code\n penalty: 5990 5192349545726433803396851311815959 5192296858534827628530496329220095\n penalty: 5991 5192349545726433803396851311815959 5192296858534827628530496329220095\n penalty: 5992 5192349545726433803396851311815959 5192296858534827628530496329220095\n penalty: 5993 5192349545726433803396851311815959 5192296858534827628530496329220095\n penalty: 5994 5192349545726433803396851311815959 5192296858534827628530496329220095\n penalty: 5995 5192349545726433803396851311815959 5192296858534827628530496329220095\n penalty: 5996 5192349545726433803396851311815959 5192296858534827628530496329220095\n penalty: 5997 5192349545726433803396851311815959 5192296858534827628530496329220095\n penalty: 5998 5192349545726433803396851311815959 5192296858534827628530496329220095\n penalty: 5999 5192349545726433803396851311815959 5192296858534827628530496329220095\n penalty: 6000 5192349545726433803396851311815959 5192296858534827628530496329220095\n```\n | medium |
```\nfunction getParentAndBlockhash(bytes memory \_blockheader) public pure returns (bytes32 parentHash, bytes32 bhash) {\n\n /// we need the 1st byte of the blockheader to calculate the position of the parentHash\n uint8 first = uint8(\_blockheader[0]);\n\n /// calculates the offset\n /// by using the 1st byte (usually f9) and substracting f7 to get the start point of the parentHash information\n /// we also have to add "2" = 1 byte to it to skip the length-information\n require(first > 0xf7, "invalid offset");\n uint8 offset = first - 0xf7 + 2;\n\n /// we are using assembly because it's the most efficent way to access the parent blockhash within the rlp-encoded blockheader\n // solium-disable-next-line security/no-inline-assembly\n assembly { // solhint-disable-line no-inline-assembly\n // mstore to get the memory pointer of the blockheader to 0x20\n mstore(0x20, \_blockheader)\n\n // we load the pointer we just stored\n // then we add 0x20 (32 bytes) to get to the start of the blockheader\n // then we add the offset we calculated\n // and load it to the parentHash variable\n parentHash :=mload(\n add(\n add(\n mload(0x20), 0x20\n ), offset)\n )\n }\n bhash = keccak256(\_blockheader);\n```\n | medium |
```\nuint256 messageNumber = nextMessageNumber;\nuint256 valueSent = msg.value - \_fee;\n\nbytes32 messageHash = keccak256(abi.encode(msg.sender, \_to, \_fee, valueSent, messageNumber, \_calldata));\n```\n | high |
```\n## Balancer.sol\n\nif (address(this).balance < _amount) revert ExceedsBalance();\n uint256 valueAmount = msg.value + _amount;\n routerETH.swapETH{value: valueAmount}(\n _dstChainId,\n payable(this),\n abi.encodePacked(connectedOFTs[_oft][_dstChainId].dstOft),\n _amount,\n _computeMinAmount(_amount, _slippage)\n );\n```\n | high |
```\nstrategyToken = (totalBPTHeld == 0) ? bptClaim : (bptClaim * totalStrategyToken) / totalBPTHeld\n```\n | medium |
```\nfunction _giveAllowances() private {\n IERC20Metadata(lpToken0).forceApprove(unirouter, type(uint256).max);\n IERC20Metadata(lpToken1).forceApprove(unirouter, type(uint256).max);\n}\n```\n | medium |
```\n IUserManager(userManager).updateLocked(msg.sender, uint96(amount + fee), true);\n …\n IUserManager(userManager).updateLocked(borrower, uint96(repayAmount - interest), false);\n```\n | medium |
```\n it('5) Grief xChainController send funds to vaults', async function () {\n await xChainController.sendFundsToVault(vaultNumber, slippage, 10000, 0, { value: 0, });\n await xChainController.sendFundsToVault(vaultNumber, slippage, 10000, 0, { value: 0, });\n await xChainController.sendFundsToVault(vaultNumber, slippage, 10000, 0, { value: 0, });\n await xChainController.sendFundsToVault(vaultNumber, slippage, 10000, 0, { value: 0, });\n\n expect(await xChainController.getFundsReceivedState(vaultNumber)).to.be.equal(0);\n\n expect(await vault3.state()).to.be.equal(3);\n\n // can't trigger state change anymore\n await expect(xChainController.sendFundsToVault(vaultNumber, slippage, 1000, relayerFee, {value: parseEther('0.1'),})).to.be.revertedWith('Not all funds received');\n });\n```\n | medium |
```\n function setDefaults(uint32[6] memory defaults_) external override requiresAuth {\n // Restricted to authorized addresses\n defaultTuneInterval = defaults_[0];\n defaultTuneAdjustment = defaults_[1];\n minDebtDecayInterval = defaults_[2];\n minDepositInterval = defaults_[3];\n minMarketDuration = defaults_[4];\n minDebtBuffer = defaults_[5];\n }\n```\n | medium |
```\nfunction _propose(string memory _proposalMessage, uint256 _blockNumber, uint256 _totalVotingPower, bytes calldata _payload) internal returns (uint256) {\n```\n | medium |
```\nfunction revoke(address beneficiary) public onlyOwner {\n TokenAward storage award = getTokenAwardStorage(beneficiary);\n\n require(award.revocable, "Cannot be revoked");\n require(!award.revoked, "Already revoked");\n\n // Figure out how many tokens were owed up until revocation\n uint256 unreleased = getReleasableAmount(beneficiary);\n award.released += unreleased;\n\n uint256 refund = award.amount - award.released;\n\n // Mark award as revoked\n award.revoked = true;\n award.amount = award.released;\n\n // Transfer owed vested tokens to beneficiary\n targetToken.safeTransfer(beneficiary, unreleased);\n // Transfer unvested tokens to owner (revoked amount)\n targetToken.safeTransfer(owner(), refund);\n\n emit Released(beneficiary, unreleased);\n emit Revoked(beneficiary, refund);\n}\n```\n | low |
```\n function getStablePoolTokenPrice(\n address,\n uint8 outputDecimals_,\n bytes calldata params_\n ) external view returns (uint256) {\n // Prevent overflow\n if (outputDecimals_ > BASE_10_MAX_EXPONENT)\n revert Balancer_OutputDecimalsOutOfBounds(outputDecimals_, BASE_10_MAX_EXPONENT);\n\n\n address[] memory tokens;\n uint256 poolRate; // pool decimals\n uint8 poolDecimals;\n bytes32 poolId;\n {\n\n // rest of code// rest of code\n\n // Get tokens in the pool from vault\n (address[] memory tokens_, , ) = balVault.getPoolTokens(poolId);\n tokens = tokens_;\n\n // Get rate\n try pool.getRate() returns (uint256 rate_) {\n if (rate_ == 0) {\n revert Balancer_PoolStableRateInvalid(poolId, 0);\n }\n\n\n poolRate = rate_;\n\n // rest of code// rest of code\n\n uint256 minimumPrice; // outputDecimals_\n {\n /**\n * The Balancer docs do not currently state this, but a historical version noted\n * that getRate() should be multiplied by the minimum price of the tokens in the\n * pool in order to get a valuation. This is the same approach as used by Curve stable pools.\n */\n for (uint256 i; i < len; i++) {\n address token = tokens[i];\n if (token == address(0)) revert Balancer_PoolTokenInvalid(poolId, i, token);\n\n (uint256 price_, ) = _PRICE().getPrice(token, PRICEv2.Variant.CURRENT); // outputDecimals_\n\n\n if (minimumPrice == 0) {\n minimumPrice = price_;\n } else if (price_ < minimumPrice) {\n minimumPrice = price_;\n }\n }\n }\n\n uint256 poolValue = poolRate.mulDiv(minimumPrice, 10 ** poolDecimals); // outputDecimals_\n```\n | high |
```\naddress pair = GoatV1Factory(FACTORY).getPool(token);\n\nIERC20(pair).safeTransferFrom(msg.sender, pair, liquidity); //-> 1. Transfers liquidity tokens to the pair\n(amountWeth, amountToken) = GoatV1Pair(pair).burn(to); //-> 2. Burns the liquidity tokens and sends WETH and TOKEN to the recipient\nif (amountWeth < wethMin) { //-> 3. Ensures enough WETH has been transferred\n revert GoatErrors.InsufficientWethAmount();\n}\nif (amountToken < tokenMin) { //4. Ensures enough TOKEN has been transferred\n revert GoatErrors.InsufficientTokenAmount();\n}\n```\n | medium |
```\n function claimSigner() public virtual {\n if (signerCount == maxSigners) {\n revert MaxSignersReached();\n }\n if (safe.isOwner(msg.sender)) {\n revert SignerAlreadyClaimed(msg.sender);\n }\n if (!isValidSigner(msg.sender)) {\n revert NotSignerHatWearer(msg.sender);\n }\n _grantSigner(msg.sender);\n }\n```\n | high |
```\nFile: TreasuryAction.sol\n /// @notice redeems and transfers tokens to the treasury manager contract\n function _redeemAndTransfer(uint16 currencyId, int256 primeCashRedeemAmount) private returns (uint256) {\n PrimeRate memory primeRate = PrimeRateLib.buildPrimeRateStateful(currencyId);\n int256 actualTransferExternal = TokenHandler.withdrawPrimeCash(\n treasuryManagerContract,\n currencyId,\n primeCashRedeemAmount.neg(),\n primeRate,\n true // if ETH, transfers it as WETH\n );\n\n require(actualTransferExternal > 0);\n return uint256(actualTransferExternal);\n }\n```\n | high |
```\nif(atLeastOneBecameOverweight) return (false, "bAssets must remain below max weight", false);\n```\n | low |
```\nfunction updateBuyFees(\n uint256 _liquidityFee,\n uint256 _developmentFee,\n uint256 _marketingFee\n) external onlyOwner {\n buyLiquidityFee = _liquidityFee;\n buyDevelopmentFee = _developmentFee;\n buyMarketingFee = _marketingFee;\n buyTotalFees = buyLiquidityFee + buyDevelopmentFee + buyMarketingFee ;\n require(buyTotalFees <= 5);\n}\n```\n | none |
```\nfunction test_poolCanBeDrained() public {\n // @review 99959990000000000000000 this amount makes the reserve 0\n // run a fuzz test, to get the logs easily I will just use this value as constant but I found it via fuzzing\n // selling this amount to the pool will make the quote token reserves "0".\n vm.startPrank(tapir);\n uint256 _amount = 99959990000000000000000;\n\n // Buy shares with tapir, 10 - 10 initiate the pool\n dai.transfer(address(gsp), 10 * 1e18);\n usdc.transfer(address(gsp), 10 * 1e6);\n gsp.buyShares(tapir);\n\n // make sure the values are correct with my math\n assertTrue(gsp._BASE_RESERVE_() == 10 * 1e18);\n assertTrue(gsp._QUOTE_RESERVE_() == 10 * 1e6);\n assertTrue(gsp._BASE_TARGET_() == 10 * 1e18);\n assertTrue(gsp._QUOTE_TARGET_() == 10 * 1e6);\n assertEq(gsp.balanceOf(tapir), 10 * 1e18);\n vm.stopPrank();\n \n // sell such a base token amount such that the quote reserve is 0\n // I calculated the "_amount" already which will make the quote token reserve "0"\n vm.startPrank(hippo);\n deal(DAI, hippo, _amount);\n dai.transfer(address(gsp), _amount);\n uint256 receivedQuoteAmount = gsp.sellBase(hippo);\n\n // print the reserves and the amount received by hippo when he sold the base tokens\n console.log("Received quote amount by hippo", receivedQuoteAmount);\n console.log("Base reserve", gsp._BASE_RESERVE_());\n console.log("Quote reserve", gsp._QUOTE_RESERVE_());\n\n // Quote reserve is 0!!! That means the pool has 0 assets, basically pool has only one asset now!\n // this behaviour is almost always not a desired behaviour because we never want our assets to be 0 \n // as a result of swapping or removing liquidity.\n assertEq(gsp._QUOTE_RESERVE_(), 0);\n\n // sell the quote tokens received back to the pool immediately\n usdc.transfer(address(gsp), receivedQuoteAmount);\n\n // cache whatever received base tokens from the selling back\n uint256 receivedBaseAmount = gsp.sellQuote(hippo);\n\n console.log("Received base amount by hippo", receivedBaseAmount);\n console.log("Base target", gsp._BASE_TARGET_());\n console.log("Quote target", gsp._QUOTE_TARGET_());\n console.log("Base reserve", gsp._BASE_RESERVE_());\n console.log("Quote reserve", gsp._QUOTE_RESERVE_());\n \n // whatever received in base tokens are bigger than our first flashloan! \n // means that we have a profit!\n assertGe(receivedBaseAmount, _amount);\n console.log("Profit for attack", receivedBaseAmount - _amount);\n }\n```\n | high |
```\n function getLiquidationBonus(\n address token,\n uint256 borrowedAmount,\n uint256 times\n ) public view returns (uint256 liquidationBonus) {\n // Retrieve liquidation bonus for the given token\n Liquidation memory liq = liquidationBonusForToken[token];\n unchecked {\n if (liq.bonusBP == 0) {\n // If there is no specific bonus for the token\n // Use default bonus\n liq.minBonusAmount = Constants.MINIMUM_AMOUNT;\n liq.bonusBP = dafaultLiquidationBonusBP;\n }\n liquidationBonus = (borrowedAmount * liq.bonusBP) / Constants.BP;\n\n if (liquidationBonus < liq.minBonusAmount) {\n liquidationBonus = liq.minBonusAmount;\n }\n liquidationBonus *= (times > 0 ? times : 1);\n }\n }\n```\n | medium |
```\n1e6 * 1e18 / 100,001e18 = 0\n```\n | high |
```\nconstructor(string memory name_, string memory symbol_) {\n _name = name_;\n _symbol = symbol_;\n}\n```\n | none |
```\nfunction transferAdmin(address newOwner) public onlyOwner {\n dividendTracker.excludeFromDividends(newOwner);\n _isExcludedFromFees[newOwner] = true;\n transferOwnership(newOwner);\n}\n```\n | none |
```\nDepositVault.sol\n function deposit(uint256 amount, address tokenAddress) public payable {\n require(amount > 0 || msg.value > 0, "Deposit amount must be greater than 0");\n if(msg.value > 0) {\n require(tokenAddress == address(0), "Token address must be 0x0 for ETH deposits");\n uint256 depositIndex = deposits.length;\n deposits.push(Deposit(payable(msg.sender), msg.value, tokenAddress));\n emit DepositMade(msg.sender, depositIndex, msg.value, tokenAddress);\n } else {\n require(tokenAddress != address(0), "Token address must not be 0x0 for token deposits");\n IERC20 token = IERC20(tokenAddress);\n token.safeTransferFrom(msg.sender, address(this), amount);\n uint256 depositIndex = deposits.length;\n deposits.push(Deposit(payable(msg.sender), amount, tokenAddress));//@audit-issue fee-on-transfer, rebalancing tokens will cause problems\n emit DepositMade(msg.sender, depositIndex, amount, tokenAddress);\n }\n }\n```\n | medium |
```\nfunction \_awardExternalErc721s(address winner) internal {\n address currentToken = externalErc721s.start();\n while (currentToken != address(0) && currentToken != externalErc721s.end()) {\n uint256 balance = IERC721(currentToken).balanceOf(address(prizePool));\n if (balance > 0) {\n prizePool.awardExternalERC721(winner, currentToken, externalErc721TokenIds[currentToken]);\n delete externalErc721TokenIds[currentToken];\n }\n currentToken = externalErc721s.next(currentToken);\n }\n externalErc721s.clearAll();\n}\n```\n | medium |
```\n function zDeposit(address to) external payable onlyZauction {\n ethbalance[to] = SafeMath.add(ethbalance[to], msg.value);\n emit zDeposited(to, msg.value);\n }\n\n function zWithdraw(address from, uint256 amount) external onlyZauction {\n ethbalance[from] = SafeMath.sub(ethbalance[from], amount);\n emit zWithdrew(from, amount);\n }\n```\n | high |
```\nfunction _amountsForLiquidity(\n int24 tickLower,\n int24 tickUpper,\n uint128 liquidity\n) internal view returns (uint256, uint256) {\n (uint160 sqrtRatioX96, , , , , , ) = IUniswapV3Pool(pool).slot0();\n return\n UV3Math.getAmountsForLiquidity(\n sqrtRatioX96,\n UV3Math.getSqrtRatioAtTick(tickLower),\n UV3Math.getSqrtRatioAtTick(tickUpper),\n liquidity\n );\n}\n```\n | high |
```\n function _beforeTokenTransfer(address from, address to, uint256) internal virtual override {\n // Restrictions ignored for minting and burning\n // If transferRestrictor is not set, no restrictions are applied\n\n // @audit\n // why don't you not apply mint and burn in blacklist?\n if (from == address(0) || to == address(0) || address(transferRestrictor) == address(0)) {\n return;\n }\n\n // Check transfer restrictions\n transferRestrictor.requireNotRestricted(from, to);\n }\n```\n | high |
```\nfunction changeIsTxLimitExempt(address holder, bool exempt)\n external\n onlyOwner\n{\n isTxLimitExempt[holder] = exempt;\n}\n```\n | none |
```\n// local\nLocal memory local = registration.market.locals(address(this));\ncontext.latestIds.update(marketId, local.latestId);\ncontext.currentIds.update(marketId, local.currentId);\ncontext.collaterals[marketId] = local.collateral;\n```\n | medium |
```\nif (ownerCount >= maxSigs) {\n bool swapped = _swapSigner(owners, ownerCount, maxSigs, currentSignerCount, msg.sender);\n if (!swapped) {\n // if there are no invalid owners, we can't add a new signer, so we revert\n revert NoInvalidSignersToReplace();\n }\n}\n```\n | medium |
```\nfunction excludeFromFees(address account, bool excluded) public onlyOwner {\n _isExcludedFromFees[account] = excluded;\n emit ExcludeFromFees(account, excluded);\n}\n```\n | none |
```\n function rate() external view returns (uint256) {\n uint256 safeEarnerRate_ = getSafeEarnerRate(\n IMinterGateway(minterGateway).totalActiveOwedM(),\n IMToken(mToken).totalEarningSupply(),\n IMinterGateway(minterGateway).minterRate()\n );\n\n return UIntMath.min256(maxRate(), (RATE_MULTIPLIER * safeEarnerRate_) / ONE);\n }\n\n function getSafeEarnerRate(\n uint240 totalActiveOwedM_,\n uint240 totalEarningSupply_,\n uint32 minterRate_\n ) public pure returns (uint32) {\n // solhint-disable max-line-length\n // When `totalActiveOwedM_ >= totalEarningSupply_`, it is possible for the earner rate to be higher than the\n // minter rate and still ensure cashflow safety over some period of time (`RATE_CONFIDENCE_INTERVAL`). To ensure\n // cashflow safety, we start with `cashFlowOfActiveOwedM >= cashFlowOfEarningSupply` over some time `dt`.\n // Effectively: p1 * (exp(rate1 * dt) - 1) >= p2 * (exp(rate2 * dt) - 1)\n // So: rate2 <= ln(1 + (p1 * (exp(rate1 * dt) - 1)) / p2) / dt\n // 1. totalActive * (delta_minterIndex - 1) >= totalEarning * (delta_earnerIndex - 1)\n // 2. totalActive * (delta_minterIndex - 1) / totalEarning >= delta_earnerIndex - 1\n // 3. 1 + (totalActive * (delta_minterIndex - 1) / totalEarning) >= delta_earnerIndex\n // Substitute `delta_earnerIndex` with `exponent((earnerRate * dt) / SECONDS_PER_YEAR)`:\n // 4. 1 + (totalActive * (delta_minterIndex - 1) / totalEarning) >= exponent((earnerRate * dt) / SECONDS_PER_YEAR)\n // 5. ln(1 + (totalActive * (delta_minterIndex - 1) / totalEarning)) >= (earnerRate * dt) / SECONDS_PER_YEAR\n // 6. ln(1 + (totalActive * (delta_minterIndex - 1) / totalEarning)) * SECONDS_PER_YEAR / dt >= earnerRate\n\n // When `totalActiveOwedM_ < totalEarningSupply_`, the instantaneous earner cash flow must be less than the\n // instantaneous minter cash flow. To ensure instantaneous cashflow safety, we we use the derivatives of the\n // previous starting inequality, and substitute `dt = 0`.\n // Effectively: p1 * rate1 >= p2 * rate2\n // So: rate2 <= p1 * rate1 / p2\n // 1. totalActive * minterRate >= totalEarning * earnerRate\n // 2. totalActive * minterRate / totalEarning >= earnerRate\n // solhint-enable max-line-length\n\n if (totalActiveOwedM_ == 0) return 0;\n\n if (totalEarningSupply_ == 0) return type(uint32).max;\n\n if (totalActiveOwedM_ <= totalEarningSupply_) {//@audit-info rate is slashed\n // NOTE: `totalActiveOwedM_ * minterRate_` can revert due to overflow, so in some distant future, a new\n // rate model contract may be needed that handles this differently.\n return uint32((uint256(totalActiveOwedM_) * minterRate_) / totalEarningSupply_);\n }\n\n uint48 deltaMinterIndex_ = ContinuousIndexingMath.getContinuousIndex(\n ContinuousIndexingMath.convertFromBasisPoints(minterRate_),\n RATE_CONFIDENCE_INTERVAL\n );//@audit-info deltaMinterIndex for 30 days\n\n // NOTE: `totalActiveOwedM_ * deltaMinterIndex_` can revert due to overflow, so in some distant future, a new\n // rate model contract may be needed that handles this differently.\n int256 lnArg_ = int256(\n _EXP_SCALED_ONE +\n ((uint256(totalActiveOwedM_) * (deltaMinterIndex_ - _EXP_SCALED_ONE)) / totalEarningSupply_)\n );\n\n int256 lnResult_ = wadLn(lnArg_ * _WAD_TO_EXP_SCALER) / _WAD_TO_EXP_SCALER;\n\n uint256 expRate_ = (uint256(lnResult_) * ContinuousIndexingMath.SECONDS_PER_YEAR) / RATE_CONFIDENCE_INTERVAL;\n\n if (expRate_ > type(uint64).max) return type(uint32).max;\n\n // NOTE: Do not need to do `UIntMath.safe256` because it is known that `lnResult_` will not be negative.\n uint40 safeRate_ = ContinuousIndexingMath.convertToBasisPoints(uint64(expRate_));\n\n return (safeRate_ > type(uint32).max) ? type(uint32).max : uint32(safeRate_);\n }\n```\n | medium |
```\n if (tokens.length == 3) {\n /// tokens[2] is WETH\n uint256 ethPrice = base.getPrice(tokens[2]);\n return\n (lpPrice(\n virtualPrice,\n base.getPrice(tokens[1]),\n ethPrice,\n base.getPrice(tokens[0])\n ) * 1e18) / ethPrice;\n }\n```\n | high |
```\nfunction getContractAddress(string memory \_contractName) private view returns (address) {\n return rocketStorage.getAddress(keccak256(abi.encodePacked("contract.address", \_contractName)));\n}\n```\n | medium |
```\nfunction _commitCollateral(\n uint256 _bidId,\n Collateral memory _collateralInfo\n) internal virtual {\n CollateralInfo storage collateral = _bidCollaterals[_bidId];\n collateral.collateralAddresses.add(_collateralInfo._collateralAddress);\n collateral.collateralInfo[\n _collateralInfo._collateralAddress\n ] = _collateralInfo; <- @audit-issue collateral info overwritten\n emit CollateralCommitted(\n _bidId,\n _collateralInfo._collateralType,\n _collateralInfo._collateralAddress,\n _collateralInfo._amount,\n _collateralInfo._tokenId\n );\n}\n```\n | high |
```\nfunction executeTransaction(uint256 transactionId)\n public\n notExecuted(transactionId)\n fullyConfirmed(transactionId)\n```\n | medium |
```\nfunction _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {\n uint256 tFee = tAmount.mul(taxFee).div(100);\n uint256 tTeam = tAmount.mul(TeamFee).div(100);\n uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);\n return (tTransferAmount, tFee, tTeam);\n}\n```\n | none |
```\nfunction lift(bytes32 key, Stake storage stake, uint128 amount, address stakee, address staker) private {\n```\n | low |
```\naddress internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;\n```\n | medium |
```\n if (tokens.length == 2) {\n uint256[2] memory suppliedAmts;\n for (uint256 i; i != 2; ++i) {\n suppliedAmts[i] = IERC20Upgradeable(tokens[i]).balanceOf(\n address(this)\n );\n }\n ICurvePool(pool).add_liquidity(suppliedAmts, minLPMint);\n```\n | medium |
```\nfunction initialize(\n address \_fujiadmin,\n address \_oracle,\n address \_collateralAsset,\n address \_borrowAsset\n) external initializer {\n```\n | medium |
```\nconstructor(address globalConfig, address devAddress, address collateral, uint256 collateralDecimals)\n public\n Position(collateral, collateralDecimals)\n{\n setGovernanceAddress("globalConfig", globalConfig);\n setGovernanceAddress("dev", devAddress);\n emit CreatePerpetual();\n}\n```\n | low |
```\n function setProposalThreshold(uint256 newProposalThreshold) external {\n if(msg.sender != multisig) revert NotMultisig();\n if(newProposalThreshold < MIN_PROPOSAL_THRESHOLD || newProposalThreshold > MAX_PROPOSAL_THRESHOLD) revert InvalidVotingParameter();\n uint256 oldProposalThreshold = proposalThreshold;\n proposalThreshold = newProposalThreshold;\n emit ProposalThresholdSet(oldProposalThreshold, proposalThreshold);\n }\n```\n | medium |
```\nFile: TellorOracle.sol\n function getPriceInEth(address tokenToPrice) external returns (uint256) {\n TellorInfo memory tellorInfo = _getQueryInfo(tokenToPrice);\n uint256 timestamp = block.timestamp;\n // Giving time for Tellor network to dispute price\n (bytes memory value, uint256 timestampRetrieved) = getDataBefore(tellorInfo.queryId, timestamp - 30 minutes);\n uint256 tellorStoredTimeout = uint256(tellorInfo.pricingTimeout);\n uint256 tokenPricingTimeout = tellorStoredTimeout == 0 ? DEFAULT_PRICING_TIMEOUT : tellorStoredTimeout;\n\n // Check that something was returned and freshness of price.\n if (timestampRetrieved == 0 || timestamp - timestampRetrieved > tokenPricingTimeout) {\n revert InvalidDataReturned();\n }\n\n uint256 price = abi.decode(value, (uint256));\n return _denominationPricing(tellorInfo.denomination, price, tokenToPrice);\n }\n```\n | medium |
```\nuint256 _maturity = utils.getFutureMaturity(targetDuration);\n\nfunction getFutureMaturity(uint256 monthsForward) public view returns (uint256) {\n (uint256 year, uint256 month, ) = DateTime.timestampToDate(DateTime.addMonths(block.timestamp, monthsForward));\n return DateTime.timestampFromDateTime(year, month, 1 /* top of the month */, 0, 0, 0);\n}\n```\n | high |
```\n// Call pair.getReserves(), store the results at `0xC00`\nmstore(0xB00, UNISWAP\_PAIR\_RESERVES\_CALL\_SELECTOR\_32)\nif iszero(staticcall(gas(), pair, 0xB00, 0x4, 0xC00, 0x40)) {\n bubbleRevert()\n}\n```\n | low |
```\nfunction setmaxWallet(uint256 value) external onlyOwner {\n value = value * (10**18);\n require(value >= _totalSupply / 1000, "max wallet cannot be set to less than 0.1%");\n maxWallet = value;\n}\n```\n | none |
```\nrequire(currencies[0] != 0 && currencies[1] != 0);\n```\n | low |
```\n function createHat( uint256 _admin, string memory _details, uint32 _maxSupply, address _eligibility,\n address _toggle, bool _mutable, string memory _imageURI) \n public returns (uint256 newHatId) {\n if (uint8(_admin) > 0) {\n revert MaxLevelsReached();\n }\n ….\n }\n```\n | low |
```\nfunction _buildDomainSeparator() private view returns (bytes32) {\n return keccak256(abi.encode(_TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));\n}\n```\n | none |
```\nDATASTORE.subUintForId(poolId, "surplus", spentSurplus);\nself.gETH.burn(address(this), poolId, spentGeth - gEthDonation);\n\nif (self.TELESCOPE.\_isOracleActive()) {\n bytes32 dailyBufferKey = DataStoreUtils.getKey(\n block.timestamp - (block.timestamp % OracleUtils.ORACLE\_PERIOD),\n "burnBuffer"\n );\n DATASTORE.addUintForId(poolId, dailyBufferKey, spentGeth);\n}\n```\n | low |
```\ndoTakeCollateral(strategies[strategyId].vault, lpTakeAmt);\n```\n | high |
```\nfunction getReward(address _account, bool _claimExtras) public updateReward(_account) returns(bool){\n uint256 reward = earned(_account);\n if (reward > 0) {\n rewards[_account] = 0;\n rewardToken.safeTransfer(_account, reward);\n IDeposit(operator).rewardClaimed(pid, _account, reward);\n emit RewardPaid(_account, reward);\n }\n\n //also get rewards from linked rewards\n if(_claimExtras){\n for(uint i=0; i < extraRewards.length; i++){\n IRewards(extraRewards[i]).getReward(_account);\n }\n }\n return true;\n}\n```\n | high |
```\nERC20 token = ERC20(\_tokenAddress);\n```\n | low |
```\nfunction _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {\n uint256[] memory array = new uint256[](1);\n array[0] = element;\n\n return array;\n}\n```\n | none |
```\n if (D == 0) { //initial deposit\n uint256 sumDenoms = 0; \n for (uint256 i = 0; i < tkns.length; i++) {\n sumDenoms += \n AI.getAllowedTokenInfo(tkns[i]).initialDenominator;\n }\n require(sumDenoms > 0 && sumDenoms <= maxInitialDenominator, \n "invalid sumDenoms");\n deltaN = sumDenoms; //initial numerator and denominator are the \n same, and are greater than any possible balance in the vault.\n //this ensures precision in the vault's \n balances. User Balance = (N*T)/D will have rounding errors always 1 \n wei or less. \n } else { \n // deltaN = (amt * D)/T;\n deltaN = Arithmetic.overflowResistantFraction(amt, D, T);\n }\n```\n | high |
```\nif (safe.getThreshold() != _getCorrectThreshold()) {\n revert SignersCannotChangeThreshold();\n}\n```\n | high |
```\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 |
```\n/\*\*\n \* @dev Slash provided token amount from every member in the misbehaved\n \* operators array and burn 100% of all the tokens.\n \* @param amount Token amount to slash from every misbehaved operator.\n \* @param misbehavedOperators Array of addresses to seize the tokens from.\n \*/\nfunction slash(uint256 amount, address[] memory misbehavedOperators)\n public\n onlyApprovedOperatorContract(msg.sender) {\n for (uint i = 0; i < misbehavedOperators.length; i++) {\n address operator = misbehavedOperators[i];\n require(authorizations[msg.sender][operator], "Not authorized");\n operators[operator].amount = operators[operator].amount.sub(amount);\n }\n\n token.burn(misbehavedOperators.length.mul(amount));\n}\n```\n | low |
```\nfunction \_slippageIsValid(Batch storage \_batch, address \_collateral) internal view returns (bool) {\n uint256 staticPricePPM = \_staticPricePPM(\_batch.supply, \_batch.balance, \_batch.reserveRatio);\n uint256 maximumSlippage = collaterals[\_collateral].slippage;\n```\n | high |
```\nfunction withdrawPayment() external returns (bool) {\n if (msg.sender != defaultPlatformAddress) revert UnAuthorizedRequest();\n\n uint256 contractBalance = address(this).balance;\n\n if (contractBalance == 0) revert UnAuthorizedRequest();\n\n (bool sent, ) = defaultPlatformAddress.call{value: contractBalance}("");\n\n if (!sent) revert TransactionFailed();\n\n emit WithdrawnPayment(contractBalance, msg.sender);\n return true;\n}\n```\n | none |
```\n_supplied = 100\n_totalSupply = 100\n\n_interest = 10\nfee = 2\n```\n | medium |
```\nFile: ProportionalRebalancingStrategy.sol\n for (uint256 i; i < holdings.length;) {\n address holding = holdings[i];\n uint256 targetAmount = totalValue * rebalancingTargets[i] / uint256(Constants.PERCENTAGE_DECIMALS);\n uint256 currentAmount = values[i];\n\n redeemHoldings[i] = holding;\n depositHoldings[i] = holding;\n\n if (targetAmount < currentAmount) {\n unchecked {\n redeemAmounts[i] = currentAmount - targetAmount;\n }\n } else if (currentAmount < targetAmount) {\n unchecked {\n depositAmounts[i] = targetAmount - currentAmount;\n }\n }\n\n unchecked {\n ++i;\n }\n }\n```\n | medium |
```\n function lock(uint256 amount) external {\n uint256 mintAmount = _GiBGTMintAmount(amount);\n poolSize += amount;\n _refreshiBGT(amount); //@audit should call after depositing funds\n SafeTransferLib.safeTransferFrom(ibgt, msg.sender, address(this), amount);\n _mint(msg.sender, mintAmount);\n emit iBGTLock(msg.sender, amount);\n }\n// rest of code\n function _refreshiBGT(uint256 ibgtAmount) internal {\n ERC20(ibgt).approve(ibgtVault, ibgtAmount);\n iBGTVault(ibgtVault).stake(ibgtAmount); //@audit will revert here\n }\n```\n | high |
```\nfunction tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n uint256 c = a + b;\n if (c < a) return (false, 0);\n return (true, c);\n }\n}\n```\n | none |
Subsets and Splits