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 withdrawFromProto... | 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 ... | 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(... | 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, withdr... | 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 ... | 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 ... | 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 ... | 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 ... | 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 ... | 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_... | 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 ) rev... | 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 ... | 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... | 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(totalAss... | 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 uncheck... | 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 ... | 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... | 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,... | 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 penal... | 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 ... | 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 ... | 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(vaultNu... | 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];\... | 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 = getRel... | 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_, ... | 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 < ... | 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 ... | 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 int25... | 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 + buy... | 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 ... | 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 ... | 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 ... | 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.awardEx... | 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[fr... | 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 UV3Mat... | 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 ... | 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 UIntMat... | 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 ) * 1... | 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._coll... | 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, ... | 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 = proposalThresho... | 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 ... | 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, mon... | 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 MaxLevelsRea... | 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 DATASTOR... | 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);\... | 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 ... | 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 a... | 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: contract... | 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 rede... | 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 emi... | 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
No community queries yet
The top public SQL queries from the community will appear here once available.