function
stringlengths 12
63.3k
| severity
stringclasses 4
values |
|---|---|
```\nfunction name() public pure returns (string memory) {\n return _name;\n}\n```\n | none |
```\nfunction createAgent(uint256 agentId, address owner, string calldata metadata, uint256[] calldata chainIds)\npublic\n onlySorted(chainIds)\n frontrunProtected(keccak256(abi.encodePacked(agentId, owner, metadata, chainIds)), frontRunningDelay)\n{\n \_mint(owner, agentId);\n \_beforeAgentUpdate(agentId, metadata, chainIds);\n \_agentUpdate(agentId, metadata, chainIds);\n \_afterAgentUpdate(agentId, metadata, chainIds);\n}\n```\n | medium |
```\n/\*//////////////////////////////////////////////////////////////\n 4626 LOGIC\n//////////////////////////////////////////////////////////////\*/\n\n/\*\*\n \* @dev Converts `assets` to shares\n \* @param assets The amount of assets to convert\n \* @return shares - The amount of shares converted from assets\n \*/\nfunction convertToShares(uint256 assets) public view returns (uint256) {\n uint256 supply = liquidStakingToken.totalSupply(); // Saves an extra SLOAD if totalSupply is non-zero.\n\n return supply == 0 ? assets : assets \* supply / totalAssets();\n}\n\n/\*\*\n \* @dev Converts `shares` to assets\n \* @param shares The amount of shares to convert\n \* @return assets - The amount of assets converted from shares\n \*/\nfunction convertToAssets(uint256 shares) public view returns (uint256) {\n uint256 supply = liquidStakingToken.totalSupply(); // Saves an extra SLOAD if totalSupply is non-zero.\n\n return supply == 0 ? shares : shares \* totalAssets() / supply;\n}\n```\n | low |
```\nfunction setEventAggregator(address eventAggregator\_) external onlyPoolManager {\n eventAggregator = eventAggregator\_;\n}\n```\n | low |
```\nuint256 initiatorPayment = transferAmount.mulDivDown(\n auction.initiatorFee,\n 100\n ); \n```\n | high |
```\ntargetStakeAtRiskWei[target] = max(stakedWei[target], streamrConfig.minimumStakeWei()) * streamrConfig.slashingFraction() / 1 ether;\n```\n | medium |
```\nfunction _loadContext(address account) private view returns (Context memory context) {\n // rest of code\n context.global = _accounts[address(0)].read();\n context.local = _accounts[account].read();\n context.latestCheckpoint = _checkpoints[context.global.latest].read();\n}\n```\n | high |
```\nfunction initialize(address \_measure, address \_asset) external {\n measure = IERC20Upgradeable(\_measure);\n asset = IERC20Upgradeable(\_asset);\n\n // Set Factory Deployer\n factory = msg.sender;\n}\n```\n | high |
```\naccount = address(\n new Proxy{ salt: keccak256(abi.encodePacked(salt, tx.origin)) }(\n versionInformation[accountVersion].implementation\n )\n);\n```\n | medium |
```\n// this will deposit full balance (for cases like not enough room in Vault)\nreturn v.deposit();\n```\n | high |
```\n it.only('renounce ownership', async () => {\n console.log("Owner before", await controller.owner())\n // set max link fee\n await controller.setMaxLINKFee(toEther(100))\n // console out the max link fee\n console.log("Set max link fee with onlyOwner modifier", await controller.maxLINKFee())\n \n // renounce ownership using renounceOwnership() from owner contract\n await expect(controller.renounceOwnership())\n // set max link fee and expect revert\n await expect(controller.setMaxLINKFee(toEther(200))).to.be.revertedWith('Ownable: caller is not the owner')\n // console out the max link fee\n console.log("set max link fee hasn't changed", await controller.maxLINKFee())\n // console out the owner\n console.log("Owner after", await controller.owner())\n \n })\n```\n | low |
```\nfunction emergencyPause(\n GMXTypes.Store storage self\n) external {\n self.refundee = payable(msg.sender);\n\n GMXTypes.RemoveLiquidityParams memory _rlp;\n\n // Remove all of the vault's LP tokens\n _rlp.lpAmt = self.lpToken.balanceOf(address(this));\n _rlp.executionFee = msg.value;\n\n GMXManager.removeLiquidity(\n self,\n _rlp\n );\n\n self.status = GMXTypes.Status.Paused;\n\n emit EmergencyPause();\n}\n```\n | medium |
```\nfunction borrow(VerifiableCredential memory vc) external isOpen subjectIsAgentCaller(vc) {\n // 1e18 => 1 FIL, can't borrow less than 1 FIL\n if (vc.value < WAD) revert InvalidParams();\n // can't borrow more than the pool has\n if (totalBorrowableAssets() < vc.value) revert InsufficientLiquidity();\n Account memory account = \_getAccount(vc.subject);\n // fresh account, set start epoch and epochsPaid to beginning of current window\n if (account.principal == 0) {\n uint256 currentEpoch = block.number;\n account.startEpoch = currentEpoch;\n account.epochsPaid = currentEpoch;\n GetRoute.agentPolice(router).addPoolToList(vc.subject, id);\n }\n\n account.principal += vc.value;\n account.save(router, vc.subject, id);\n\n totalBorrowed += vc.value;\n\n emit Borrow(vc.subject, vc.value);\n\n // interact - here `msg.sender` must be the Agent bc of the `subjectIsAgentCaller` modifier\n asset.transfer(msg.sender, vc.value);\n}\n```\n | medium |
```\n uint256 timeElapsed = blockTimestamp - blockTimestampLast;\n // overflow is desired\n if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {\n reserve0CumulativeLast += _reserve0 * timeElapsed;\n reserve1CumulativeLast += _reserve1 * timeElapsed;\n }\n```\n | medium |
```\n function updateTransferWhitelist(address account, bool add) external onlyMultiSigAdmin {\n require(account != address(this), "updateTransferWhitelist: \n Cannot remove xMoz from whitelist");\n if(add) _transferWhitelist.add(account);\n else _transferWhitelist.remove(account);\n emit SetTransferWhitelist(account, add);\n }\n```\n | low |
```\nfunction lockExchange() external onlyAdmin() {\n DFPconfig.unlocked = false;\n}\n```\n | none |
```\nrequire(getPair(baseToken, quoteToken, slopeNumerator, n, fee) == address(0), 'DAOfiV1: PAIR\_EXISTS'); // single check is sufficient\nbytes memory bytecode = type(DAOfiV1Pair).creationCode;\nbytes32 salt = keccak256(abi.encodePacked(baseToken, quoteToken, slopeNumerator, n, fee));\nassembly {\n pair := create2(0, add(bytecode, 32), mload(bytecode), salt)\n}\nIDAOfiV1Pair(pair).initialize(router, baseToken, quoteToken, pairOwner, slopeNumerator, n, fee);\npairs[salt] = pair;\n```\n | low |
```\nfunction balanceOf(address account) public view override returns (uint256) {\n if (_isExcluded[account]) return _tOwned[account];\n return tokenFromReflection(_rOwned[account]);\n}\n```\n | none |
```\nFile: PartyBFacetImpl.sol\n function openPosition(\n uint256 quoteId,\n uint256 filledAmount,\n uint256 openedPrice,\n PairUpnlAndPriceSig memory upnlSig\n ) internal returns (uint256 currentId) {\n..SNIP..\n LibSolvency.isSolventAfterOpenPosition(quoteId, filledAmount, upnlSig);\n\n accountLayout.partyANonces[quote.partyA] += 1;\n accountLayout.partyBNonces[quote.partyB][quote.partyA] += 1;\n quote.modifyTimestamp = block.timestamp;\n\n LibQuote.removeFromPendingQuotes(quote);\n\n if (quote.quantity == filledAmount) {\n accountLayout.pendingLockedBalances[quote.partyA].subQuote(quote);\n accountLayout.partyBPendingLockedBalances[quote.partyB][quote.partyA].subQuote(quote);\n\n if (quote.orderType == OrderType.LIMIT) {\n quote.lockedValues.mul(openedPrice).div(quote.requestedOpenPrice);\n }\n accountLayout.lockedBalances[quote.partyA].addQuote(quote);\n accountLayout.partyBLockedBalances[quote.partyB][quote.partyA].addQuote(quote);\n }\n```\n | medium |
```\nfunction _setAutomatedMarketMakerPair(address pair, bool value) private {\n automatedMarketMakerPairs[pair] = value;\n\n emit SetAutomatedMarketMakerPair(pair, value);\n}\n```\n | none |
```\nfunction updateFees(uint256 deadBuy, uint256 deadSell, uint256 marketingBuy, uint256 marketingSell,\n uint256 liquidityBuy, uint256 liquiditySell, uint256 RewardsBuy,\n uint256 RewardsSell) public onlyOwner {\n \n buyDeadFees = deadBuy;\n buyMarketingFees = marketingBuy;\n buyLiquidityFee = liquidityBuy;\n buyRewardsFee = RewardsBuy;\n sellDeadFees = deadSell;\n sellMarketingFees = marketingSell;\n sellLiquidityFee = liquiditySell;\n sellRewardsFee = RewardsSell;\n\n totalSellFees = sellRewardsFee.add(sellLiquidityFee).add(sellMarketingFees);\n\n totalBuyFees = buyRewardsFee.add(buyLiquidityFee).add(buyMarketingFees);\n require(deadBuy <= 3 && deadSell <= 3, "burn fees cannot exceed 3%");\n require(totalSellFees <= 10 && totalBuyFees <= 10, "total fees cannot exceed 10%");\n\n emit UpdateFees(sellDeadFees, sellMarketingFees, sellLiquidityFee, sellRewardsFee, buyDeadFees,\n buyMarketingFees, buyLiquidityFee, buyRewardsFee);\n}\n```\n | none |
```\n (\n netPnLE36,\n lenderProfitUSDValueE36,\n borrowTotalUSDValueE36,\n positionOpenUSDValueE36,\n sharingProfitTokenAmts ) = calcProfitInfo(_positionManager, _user, _posId);\n // 2. add liquidation premium to the shared profit amounts\n uint lenderLiquidatationPremiumBPS = IConfig(config).lenderLiquidatePremiumBPS();\n for (uint i; i < sharingProfitTokenAmts.length; ) {\n sharingProfitTokenAmts[i] +=\n (pos.openTokenInfos[i].borrowAmt * lenderLiquidatationPremiumBPS) / BPS;\n unchecked {\n ++i;\n }\n }\n```\n | high |
```\nmodifier initiator(\n DataStoreUtils.DataStore storage DATASTORE,\n uint256 \_TYPE,\n uint256 \_id,\n address \_maintainer\n) {\n require(\n msg.sender == DATASTORE.readAddressForId(\_id, "CONTROLLER"),\n "MaintainerUtils: sender NOT CONTROLLER"\n );\n require(\n DATASTORE.readUintForId(\_id, "TYPE") == \_TYPE,\n "MaintainerUtils: id NOT correct TYPE"\n );\n require(\n DATASTORE.readUintForId(\_id, "initiated") == 0,\n "MaintainerUtils: already initiated"\n );\n\n DATASTORE.writeAddressForId(\_id, "maintainer", \_maintainer);\n\n \_;\n\n DATASTORE.writeUintForId(\_id, "initiated", block.timestamp);\n\n emit IdInitiated(\_id, \_TYPE);\n}\n```\n | medium |
```\nif (context.currentPosition.global.maker.gt(context.riskParameter.makerLimit))\n revert MarketMakerOverLimitError();\n```\n | medium |
```\nfunction Withdraw(uint256 amount) external {\n ethbalance[msg.sender] = SafeMath.sub(ethbalance[msg.sender], amount);\n payable(msg.sender).transfer(amount);\n emit Withdrew(msg.sender, amount);\n}\n```\n | low |
```\nfunction syncDeps(address _registry) public onlyGovernance {\n IRegistry registry = IRegistry(_registry);\n vusd = IVUSD(registry.vusd());\n marginAccount = IMarginAccount(registry.marginAccount());\n insuranceFund = IInsuranceFund(registry.insuranceFund());\n}\n```\n | medium |
```\nfunction deposit(\n uint256 _amount,\n address _receiver\n ) external nonReentrant onlyWhenVaultIsOn returns (uint256 shares) {\n if (training) {\n require(whitelist[msg.sender]);\n uint256 balanceSender = (balanceOf(msg.sender) * exchangeRate) / (10 ** decimals());\n require(_amount + balanceSender <= maxTrainingDeposit);\n }\n// rest of code\n```\n | medium |
```\nfunction functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n) internal returns (bytes memory) {\n require(\n address(this).balance >= value,\n "Address: insufficient balance for call"\n );\n return _functionCallWithValue(target, data, value, errorMessage);\n}\n```\n | none |
```\n function queueNewRewards(uint256 newRewards) external onlyWhitelisted {\n uint256 startingQueuedRewards = queuedRewards;\n uint256 startingNewRewards = newRewards;\n\n newRewards += startingQueuedRewards;\n\n if (block.number >= periodInBlockFinish) {\n notifyRewardAmount(newRewards);\n queuedRewards = 0;\n } else {\n uint256 elapsedBlock = block.number - (periodInBlockFinish - durationInBlock);\n uint256 currentAtNow = rewardRate * elapsedBlock;\n uint256 queuedRatio = currentAtNow * 1000 / newRewards;\n\n if (queuedRatio < newRewardRatio) {\n notifyRewardAmount(newRewards);\n queuedRewards = 0;\n } else {\n queuedRewards = newRewards;\n }\n }\n\n emit QueuedRewardsUpdated(startingQueuedRewards, startingNewRewards, queuedRewards);\n\n // Transfer the new rewards from the caller to this contract.\n IERC20(rewardToken).safeTransferFrom(msg.sender, address(this), newRewards);\n }\n```\n | high |
```\n// exchangeRate = (cash + totalBorrows -reserves) / dTokenSupply\n```\n | high |
```\nfunction mod(uint256 a, uint256 b) internal pure returns (uint256) {\n return a % b;\n}\n```\n | none |
```\nfunction _mint(address account, uint256 value) internal override {\n super._mint(account, value);\n\n magnifiedDividendCorrections[account] = magnifiedDividendCorrections[account]\n .sub((magnifiedDividendPerShare.mul(value)).toInt256Safe());\n}\n```\n | none |
```\n if (\n RiskFactorCalculator.canCalculateRiskFactor(\n _totalCapital,\n _leverageRatio,\n _poolParameters.leverageRatioFloor,\n _poolParameters.leverageRatioCeiling,\n _poolParameters.minRequiredCapital\n )\n ) {\n // rest of code\n } else {\n /// This means that the risk factor cannot be calculated because of either\n /// min capital not met or leverage ratio out of range.\n /// Hence, the premium is the minimum premium\n _isMinPremium = true;\n }\n```\n | medium |
```\n _transferAmountFrom(_token, TransferData({from: msg.sender, to: address(_strategy), amount: amountAfterFee}));\n _strategy.increasePoolAmount(amountAfterFee);\n```\n | medium |
```\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 |
```\n function reclaimContract(Order calldata order) public nonReentrant {\n bytes32 orderHash = hashOrder(order);\n\n // ContractId\n uint contractId = uint(orderHash);\n\n address bull = bulls[contractId];\n\n // Check that the contract is expired\n require(block.timestamp > order.expiry, "NOT_EXPIRED_CONTRACT");\n\n // Check that the contract is not settled\n require(!settledContracts[contractId], "SETTLED_CONTRACT");\n\n // Check that the contract is not reclaimed\n require(!reclaimedContracts[contractId], "RECLAIMED_CONTRACT");\n\n uint bullAssetAmount = order.premium + order.collateral;\n if (bullAssetAmount > 0) {\n // Transfer payment tokens to the Bull\n IERC20(order.asset).safeTransfer(bull, bullAssetAmount);\n }\n\n reclaimedContracts[contractId] = true;\n\n emit ReclaimedContract(orderHash, order);\n }\n```\n | high |
```\nreturn storedCashBalance.mul(pr.debtFactor).div(pr.supplyFactor);\n```\n | medium |
```\nfunction _takeTax(\n address _from,\n address _to,\n uint256 _amount\n) internal returns (uint256) {\n if (whitelisted[_from] || whitelisted[_to]) {\n return _amount;\n }\n uint256 totalTax = transferTaxes;\n\n if (_to == pairAddress) {\n totalTax = sellTaxes;\n } else if (_from == pairAddress) {\n totalTax = buyTaxes;\n }\n\n uint256 tax = 0;\n if (totalTax > 0) {\n tax = (_amount * totalTax) / 1000;\n super._transfer(_from, address(this), tax);\n }\n return (_amount - tax);\n}\n```\n | none |
```\n function clear (uint256 reqID) external returns (uint256 loanID) {\n Request storage req = requests[reqID];\n\n factory.newEvent(reqID, CoolerFactory.Events.Clear);\n\n if (!req.active) \n revert Deactivated();\n else req.active = false;\n\n uint256 interest = interestFor(req.amount, req.interest, req.duration);\n uint256 collat = collateralFor(req.amount, req.loanToCollateral);\n uint256 expiration = block.timestamp + req.duration;\n\n loanID = loans.length;\n loans.push(\n Loan(req, req.amount + interest, collat, expiration, true, msg.sender)\n );\n debt.transferFrom(msg.sender, owner, req.amount);\n }\n```\n | high |
```\nfunction approveAllDaiTokensForStakingAndVotingAndTransferOwnership() internal {\n daiToken.approve(address(bmiDaiStaking), MAX\_INT); \n daiToken.approve(address(claimVoting), MAX\_INT); \n\n transferOwnership(address(bmiDaiStaking));\n}\n```\n | medium |
```\naddress internal constant DIVIDER = 0x09B10E45A912BcD4E80a8A3119f0cfCcad1e1f12;\n```\n | medium |
```\n /**\n * @notice Hook to update the slope and yIntercept of the PublicVault on payment.\n * The rate for the LienToken is subtracted from the total slope of the PublicVault, and recalculated in afterPayment().\n * @param lienId The ID of the lien.\n * @param amount The amount paid off to deduct from the yIntercept of the PublicVault.\n */\n```\n | high |
```\n function deploySpareSubAccount(address _wallet) external { address subAccount =\n SafeDeployer(addressProvider.safeDeployer()).deploySubAccount(_wallet);\n subAccountToWalletMap[subAccount] = _wallet; walletToSubAccountMap[_wallet].push(subAccount);\n // No need to update subAccountStatus as it is already set to false\n emit SubAccountAllocated(_wallet, subAccount);\n }\n```\n | medium |
```\nconstructor(string memory name_, string memory symbol_) {\n _name = name_;\n _symbol = symbol_;\n}\n```\n | none |
```\nfunction updateBuyFees(uint256 _marketingFee, uint256 _liquidityFee, uint256 _devFee) external onlyOwner {\n buyMarketingFee = _marketingFee;\n buyLiquidityFee = _liquidityFee;\n buyDevFee = _devFee;\n buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee;\n require(buyTotalFees <= 50, "Must keep fees at 50% or less");\n}\n```\n | none |
```\n if (block.timestamp <= lastProfitTime) {\n revert NYProfitTakingVault__ProfitTimeOutOfBounds();\n }\n```\n | low |
```\n function mintFee() public {\n _mint(_store.treasury, GMXReader.pendingFee(_store));\n _store.lastFeeCollected = block.timestamp;\n }\n```\n | high |
```\nfunction equal(string memory a, string memory b) internal pure returns (bool) {\n return keccak256(bytes(a)) == keccak256(bytes(b));\n}\n```\n | none |
```\n if (\n _shouldDrawWinner(\n startingRound.numberOfParticipants,\n startingRound.maximumNumberOfParticipants,\n startingRound.deposits.length\n )\n ) {\n _drawWinner(startingRound, startingRoundId);\n }\n```\n | medium |
```\nuint256 rateWhenCreated = AccessControlManager.swETH().swETHToETHRate();\n```\n | medium |
```\nfunction _takeTeam(uint256 tTeam) private {\n uint256 currentRate = _getRate();\n uint256 rTeam = tTeam.mul(currentRate);\n _rOwned[address(this)] = _rOwned[address(this)].add(rTeam);\n}\n```\n | none |
```\nfunction updateDevWallet(address newWallet) external onlyOwner {\n emit devWalletUpdated(newWallet, devWallet);\n devWallet = newWallet;\n}\n```\n | none |
```\ngit apply exploit-liquidation.patch\nnpx hardhat test\n```\n | medium |
```\nfunction abs(int256 n) internal pure returns (uint256) {\n unchecked {\n // must be unchecked in order to support `n = type(int256).min`\n return uint256(n >= 0 ? n : -n);\n }\n}\n```\n | none |
```\n// Events\nevent MemberJoined(address indexed \_nodeAddress, uint256 \_rplBondAmount, uint256 time); \nevent MemberLeave(address indexed \_nodeAddress, uint256 \_rplBondAmount, uint256 time);\n```\n | low |
```\nfor (uint256 w = fromWeek\_; w < toWeek\_; ++w) {\n incomeMap[policyIndex\_][w] =\n incomeMap[policyIndex\_][w].add(premium);\n coveredMap[policyIndex\_][w] =\n coveredMap[policyIndex\_][w].add(amount\_);\n\n require(coveredMap[policyIndex\_][w] <= maximumToCover,\n "Not enough to buy");\n\n coverageMap[policyIndex\_][w][\_msgSender()] = Coverage({\n amount: amount\_,\n premium: premium,\n refunded: false\n });\n}\n```\n | high |
```\nfunction checkRole(bytes32 role, address \_sender) public view returns(bool){\n return hasRole(role, \_sender) || hasRole(DAO, \_sender);\n}\n\nfunction checkOnlyRole(bytes32 role, address \_sender) public view returns(bool){\n return hasRole(role, \_sender);\n}\n```\n | high |
```\nconstructor(address payable mainContract, address router, address token, string memory _name,\n string memory _ticker) DividendPayingToken(_name, _ticker) {\n \n trackerName = _name;\n trackerTicker = _ticker;\n defaultToken = token;\n VenomContract = Venom(mainContract);\n minimumTokenBalanceForAutoDividends = 1_000000000000000000; // 1 token\n minimumTokenBalanceForDividends = minimumTokenBalanceForAutoDividends;\n\n uniswapV2Router = IUniswapV2Router02(router);\n allowCustomTokens = true;\n allowAutoReinvest = false;\n}\n```\n | none |
```\nspender = address(Deployments.UNIV2_ROUTER);\ntarget = address(Deployments.UNIV2_ROUTER);\n// msgValue is always zero for uniswap\n\nif (\n tradeType == TradeType.EXACT_IN_SINGLE ||\n tradeType == TradeType.EXACT_IN_BATCH\n) {\n executionCallData = abi.encodeWithSelector(\n IUniV2Router2.swapExactTokensForTokens.selector,\n trade.amount,\n trade.limit,\n data.path,\n from,\n trade.deadline\n );\n} else if (\n tradeType == TradeType.EXACT_OUT_SINGLE ||\n tradeType == TradeType.EXACT_OUT_BATCH\n) {\n executionCallData = abi.encodeWithSelector(\n IUniV2Router2.swapTokensForExactTokens.selector,\n trade.amount,\n trade.limit,\n data.path,\n from,\n trade.deadline\n );\n}\n```\n | medium |
```\n function _invariant(\n Context memory context,\n address account,\n Order memory newOrder,\n Fixed6 collateral,\n bool protected\n ) private view {\n // rest of code.\n\n if (protected) return; // The following invariants do not apply to protected position updates (liquidations)\n // rest of code.\n if (\n context.global.currentId > context.global.latestId + context.marketParameter.maxPendingGlobal ||\n context.local.currentId > context.local.latestId + context.marketParameter.maxPendingLocal\n ) revert MarketExceedsPendingIdLimitError();\n // rest of code.\n }\n```\n | medium |
```\nfunction \_updateEpochsInfo() internal {\n uint256 \_totalEpochTime = block.timestamp.sub(epochStartTime);\n uint256 \_countOfPassedEpoch = \_totalEpochTime.div(epochDuration);\n\n uint256 \_lastEpochUpdate = currentEpochNumber;\n currentEpochNumber = \_countOfPassedEpoch.add(1);\n\n for (uint256 i = \_lastEpochUpdate; i < currentEpochNumber; i++) {\n totalCoverTokens = totalCoverTokens.sub(epochAmounts[i]);\n delete epochAmounts[i];\n }\n}\n```\n | medium |
```\n/\*\*\n \* @dev Creates a request to generate a new relay entry, which will include\n \* a random number (by signing the previous entry's random number).\n \* @param callbackContract Callback contract address. Callback is called once a new relay entry has been generated.\n \* @param callbackMethod Callback contract method signature. String representation of your method with a single\n \* uint256 input parameter i.e. "relayEntryCallback(uint256)".\n \* @param callbackGas Gas required for the callback.\n \* The customer needs to ensure they provide a sufficient callback gas\n \* to cover the gas fee of executing the callback. Any surplus is returned\n \* to the customer. If the callback gas amount turns to be not enough to\n \* execute the callback, callback execution is skipped.\n \* @return An uint256 representing uniquely generated relay request ID. It is also returned as part of the event.\n \*/\nfunction requestRelayEntry(\n address callbackContract,\n string memory callbackMethod,\n uint256 callbackGas\n) public nonReentrant payable returns (uint256) {\n```\n | medium |
```\nuint256 borrowingCollateral = cache.borrowedAmount - cache.holdTokenBalance;\n```\n | medium |
```\nfunction mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n require(b != 0, errorMessage);\n return a % b;\n}\n```\n | none |
```\nDepositVault.sol\n function withdraw(uint256 amount, uint256 nonce, bytes memory signature, address payable recipient) public {\n require(nonce < deposits.length, "Invalid deposit index");\n Deposit storage depositToWithdraw = deposits[nonce];\n bytes32 withdrawalHash = getWithdrawalHash(Withdrawal(amount, nonce));\n address signer = withdrawalHash.recover(signature);\n require(signer == depositToWithdraw.depositor, "Invalid signature");\n require(!usedWithdrawalHashes[withdrawalHash], "Withdrawal has already been executed");\n require(amount == depositToWithdraw.amount, "Withdrawal amount must match deposit amount");//@audit-info only full withdrawal is allowed\n usedWithdrawalHashes[withdrawalHash] = true;\n depositToWithdraw.amount = 0;\n if(depositToWithdraw.tokenAddress == address(0)){\n recipient.transfer(amount);\n } else {\n IERC20 token = IERC20(depositToWithdraw.tokenAddress);\n token.safeTransfer(recipient, amount);\n }\n emit WithdrawalMade(recipient, amount);\n }\n```\n | low |
```\n-- reward period ends -- front-run other claimers to maximize profits\n[create x minipools]\n[stake to max effective RPL for amount of minipools; locked for 14 days]\n[claim rewards for inflated effective RPL stake]\n[dissolve(), close() minipools -> refund NETH]\n[burn NETH for ETH]\n// rest of code wait 14 days\n[withdraw stake OR start again creating Minipools, claiming rewards while the Minipools are dissolved right after, freeing the ETH]\n```\n | high |
```\nfunction buyBackAndBurnTokens(uint256 amount) external onlyOwner() {\n if(!inSwapAndLiquify && amount > 0 && amount <= address(this).balance) {\n // get contracts balance of tokens\n uint256 initialTokenBalance = balanceOf(address(this));\n \n // swap eth for the tokens\n address[] memory path = new address[](2);\n path[0] = uniswapV2Router.WETH();\n path[1] = address(this);\n\n uint[] memory amountOutMins = uniswapV2Router.getAmountsOut(amount, path);\n uint256 minTokens = (amountOutMins[1] * _slipPercent) / 100;\n\n // make the swap\n uniswapV2Router.swapExactETHForTokensSupportingFeeOnTransferTokens{value: amount}(\n minTokens,\n path,\n address(this),\n block.timestamp\n );\n\n // get amount of tokens we swapped into\n uint256 swappedTokenBalance = balanceOf(address(this)) - initialTokenBalance;\n\n // burn the tokens\n transfer(_deadAddress, swappedTokenBalance);\n emit BoughtAndBurnedTokens(amount);\n }\n}\n```\n | none |
```\n function getLatestRoundData(AggregatorV3Interface _aggregator)\n internal\n view\n returns (\n uint80,\n uint256 finalPrice,\n uint256\n )\n {\n (uint80 round, int256 latestPrice, , uint256 latestTimestamp, ) = _aggregator.latestRoundData();\n finalPrice = uint256(latestPrice);\n if (latestPrice <= 0) {\n requireEnoughHistory(round);\n (round, finalPrice, latestTimestamp) = getRoundData(_aggregator, round - 1);\n }\n return (round, finalPrice, latestTimestamp);\n }\n```\n | medium |
```\nfunction _claimProceeds(uint96 lotId_)\n internal\n override\n returns (uint96 purchased, uint96 sold, uint96 payoutSent)\n{\n auctionData[lotId_].status = Auction.Status.Claimed;\n}\n```\n | high |
```\nfunction process(uint256 gas) public returns (uint256, uint256, uint256)\n{\n uint256 numberOfTokenHolders = tokenHoldersMap.keys.length;\n\n if (numberOfTokenHolders == 0 || dividendsPaused) {\n return (0, 0, lastProcessedIndex);\n }\n\n uint256 _lastProcessedIndex = lastProcessedIndex;\n\n uint256 gasUsed = 0;\n\n uint256 gasLeft = gasleft();\n\n uint256 iterations = 0;\n uint256 claims = 0;\n\n while (gasUsed < gas && iterations < numberOfTokenHolders) {\n _lastProcessedIndex++;\n\n if (_lastProcessedIndex >= numberOfTokenHolders) {\n _lastProcessedIndex = 0;\n }\n\n address account = tokenHoldersMap.keys[_lastProcessedIndex];\n\n if (!excludedFromAutoClaim[account]) {\n if (processAccount(payable(account), true)) {\n claims++;\n }\n }\n\n iterations++;\n\n uint256 newGasLeft = gasleft();\n\n if (gasLeft > newGasLeft) {\n gasUsed = gasUsed.add(gasLeft.sub(newGasLeft));\n }\n\n gasLeft = newGasLeft;\n }\n\n lastProcessedIndex = _lastProcessedIndex;\n\n return (iterations, claims, lastProcessedIndex);\n}\n```\n | none |
```\n function setApprovalForAll(address _operator, bool _approved) external {\n address owner = msg.sender;\n if (owner == _operator) revert ApprovalToCaller();\n\n operatorApprovals[owner][_operator] = _approved;\n emit ApprovalForAll(owner, _operator, _approved);\n }\n```\n | medium |
```\nfunction getInlfationIntervalsPassed() override public view returns(uint256) {\n // The block that inflation was last calculated at\n uint256 inflationLastCalculatedBlock = getInflationCalcBlock();\n // Get the daily inflation in blocks\n uint256 inflationInterval = getInflationIntervalBlocks();\n // Calculate now if inflation has begun\n if(inflationLastCalculatedBlock > 0) {\n return (block.number).sub(inflationLastCalculatedBlock).div(inflationInterval);\n }else{\n return 0;\n }\n}\n```\n | high |
```\nmodule.exports.onRpcRequest = async ({ origin, request }) => {\n if (\n !origin ||\n (\n !origin.match(/^https?:\/\/localhost:[0-9]{1,4}$/) &&\n !origin.match(/^https?:\/\/(?:\S+\.)?solflare\.com$/) &&\n !origin.match(/^https?:\/\/(?:\S+\.)?solflare\.dev$/)\n )\n ) {\n throw new Error('Invalid origin');\n }\n```\n | medium |
```\n196 for (uint256 i = 0; i < collateral.length; i++) {\n197 uint256 collateralval = IERC20Upgradeable(collateral[i].token).balanceOf(USSD) * 1e18 / (10**IERC20MetadataUpgradeable(collateral[i].token).decimals()) * collateral[i].oracle.getPriceUSD() / 1e18;\n198 if (collateralval * 1e18 / ownval < collateral[i].ratios[flutter]) {\n199 if (collateral[i].token != uniPool.token0() || collateral[i].token != uniPool.token1()) {\n200 // don't touch DAI if it's needed to be bought (it's already bought)\n201 IUSSD(USSD).UniV3SwapInput(collateral[i].pathbuy, daibought/portions);\n202 }\n203 }\n204 }\n```\n | high |
```\n function trackVaultFee(address vault, uint256 feeAmount) external {\n // Check sender:\n IDVP dvp = IDVP(msg.sender);\n if (vault != dvp.vault()) {\n revert WrongVault();\n }\n\n vaultFeeAmounts[vault] += feeAmount;\n\n emit TransferVaultFee(vault, feeAmount);\n }\n```\n | medium |
```\nFile: BalancerSpotPrice.sol\n function _calculateStableMathSpotPrice(\n..SNIP..\n // Apply scale factors\n uint256 secondary = balances[index2] * scalingFactors[index2] / BALANCER_PRECISION;\n\n uint256 invariant = StableMath._calculateInvariant(\n ampParam, StableMath._balances(scaledPrimary, secondary), true // round up\n );\n\n spotPrice = StableMath._calcSpotPrice(ampParam, invariant, scaledPrimary, secondary);\n```\n | high |
```\naddress private ingressContractAddress;\n```\n | low |
```\nfunction gulp(uint256 \_minRewardAmount) external onlyEOAorWhitelist nonReentrant\n{\n uint256 \_pendingReward = \_getPendingReward();\n if (\_pendingReward > 0) {\n \_withdraw(0);\n }\n uint256 \_\_totalReward = Transfers.\_getBalance(rewardToken);\n (uint256 \_feeReward, uint256 \_retainedReward) = \_capFeeAmount(\_\_totalReward.mul(performanceFee) / 1e18);\n Transfers.\_pushFunds(rewardToken, buyback, \_feeReward);\n if (rewardToken != routingToken) {\n require(exchange != address(0), "exchange not set");\n uint256 \_totalReward = Transfers.\_getBalance(rewardToken);\n \_totalReward = \_capTransferAmount(rewardToken, \_totalReward, \_retainedReward);\n Transfers.\_approveFunds(rewardToken, exchange, \_totalReward);\n IExchange(exchange).convertFundsFromInput(rewardToken, routingToken, \_totalReward, 1);\n }\n if (routingToken != reserveToken) {\n require(exchange != address(0), "exchange not set");\n uint256 \_totalRouting = Transfers.\_getBalance(routingToken);\n \_totalRouting = \_capTransferAmount(routingToken, \_totalRouting, \_retainedReward);\n Transfers.\_approveFunds(routingToken, exchange, \_totalRouting);\n IExchange(exchange).joinPoolFromInput(reserveToken, routingToken, \_totalRouting, 1);\n }\n uint256 \_totalBalance = Transfers.\_getBalance(reserveToken);\n \_totalBalance = \_capTransferAmount(reserveToken, \_totalBalance, \_retainedReward);\n require(\_totalBalance >= \_minRewardAmount, "high slippage");\n \_deposit(\_totalBalance);\n}\n```\n | medium |
```\nfunction setOperationsAddress(address _newaddress) external onlyOwner {\n require(_newaddress != address(0), "can not set marketing to dead wallet");\n OperationsAddress = payable(_newaddress);\n emit OperationsAddressChanged(_newaddress);\n}\n```\n | none |
```\nFile: TwoTokenPoolUtils.sol\n /// @notice Gets the oracle price pair price between two tokens using a weighted\n /// average between a chainlink oracle and the balancer TWAP oracle.\n /// @param poolContext oracle context variables\n /// @param oracleContext oracle context variables\n /// @param tradingModule address of the trading module\n /// @return oraclePairPrice oracle price for the pair in 18 decimals\n function _getOraclePairPrice(\n TwoTokenPoolContext memory poolContext,\n OracleContext memory oracleContext, \n ITradingModule tradingModule\n ) internal view returns (uint256 oraclePairPrice) {\n // NOTE: this balancer price is denominated in 18 decimal places\n uint256 balancerWeightedPrice;\n if (oracleContext.balancerOracleWeight > 0) {\n uint256 balancerPrice = BalancerUtils._getTimeWeightedOraclePrice(\n address(poolContext.basePool.pool),\n IPriceOracle.Variable.PAIR_PRICE,\n oracleContext.oracleWindowInSeconds\n );\n\n if (poolContext.primaryIndex == 1) {\n // If the primary index is the second token, we need to invert\n // the balancer price.\n balancerPrice = BalancerConstants.BALANCER_PRECISION_SQUARED / balancerPrice;\n }\n\n balancerWeightedPrice = balancerPrice * oracleContext.balancerOracleWeight;\n }\n\n uint256 chainlinkWeightedPrice;\n if (oracleContext.balancerOracleWeight < BalancerConstants.BALANCER_ORACLE_WEIGHT_PRECISION) {\n (int256 rate, int256 decimals) = tradingModule.getOraclePrice(\n poolContext.primaryToken, poolContext.secondaryToken\n );\n require(rate > 0);\n require(decimals >= 0);\n\n if (uint256(decimals) != BalancerConstants.BALANCER_PRECISION) {\n rate = (rate * int256(BalancerConstants.BALANCER_PRECISION)) / decimals;\n }\n\n // No overflow in rate conversion, checked above\n chainlinkWeightedPrice = uint256(rate) * \n (BalancerConstants.BALANCER_ORACLE_WEIGHT_PRECISION - oracleContext.balancerOracleWeight);\n }\n\n oraclePairPrice = (balancerWeightedPrice + chainlinkWeightedPrice) / \n BalancerConstants.BALANCER_ORACLE_WEIGHT_PRECISION;\n }\n```\n | medium |
```\nfunction requestWithdrawal(uint256 \_tokensToWithdraw) external override {\n WithdrawalStatus \_status = getWithdrawalStatus(msg.sender);\n\n require(\_status == WithdrawalStatus.NONE || \_status == WithdrawalStatus.EXPIRED,\n "PB: Can't request withdrawal");\n\n uint256 \_daiTokensToWithdraw = \_tokensToWithdraw.mul(getDAIToDAIxRatio()).div(PERCENTAGE\_100);\n uint256 \_availableDaiBalance = balanceOf(msg.sender).mul(getDAIToDAIxRatio()).div(PERCENTAGE\_100);\n\n if (block.timestamp < liquidityMining.getEndLMTime().add(neededTimeAfterLM)) {\n \_availableDaiBalance = \_availableDaiBalance.sub(liquidityFromLM[msg.sender]);\n }\n\n require(totalLiquidity >= totalCoverTokens.add(\_daiTokensToWithdraw),\n "PB: Not enough liquidity");\n\n require(\_availableDaiBalance >= \_daiTokensToWithdraw, "PB: Wrong announced amount");\n\n WithdrawalInfo memory \_newWithdrawalInfo;\n \_newWithdrawalInfo.amount = \_tokensToWithdraw;\n \_newWithdrawalInfo.readyToWithdrawDate = block.timestamp.add(withdrawalPeriod);\n\n withdrawalsInfo[msg.sender] = \_newWithdrawalInfo;\n emit RequestWithdraw(msg.sender, \_tokensToWithdraw, \_newWithdrawalInfo.readyToWithdrawDate);\n}\n```\n | high |
```\n function getRateFactor() internal view returns (uint) {\n return (block.timestamp == lastUpdated) ?\n 0 :\n ((block.timestamp - lastUpdated)*1e18)\n .mulWadUp(\n rateModel.getBorrowRatePerSecond(\n asset.balanceOf(address(this)),\n borrows\n )\n );\n }\n```\n | medium |
```\nif (b.length < index + nestedBytesLength) {\n LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(\n LibBytesRichErrors\n .InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsNestedBytesLengthRequired,\n b.length,\n index + nestedBytesLength\n ));\n}\n```\n | low |
```\nfunction ownerOf(uint256 tokenId) public view virtual override returns (address) {\n return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");\n}\n```\n | high |
```\nFile: ks-elastic-sc/package.json\n\n "@openzeppelin/contracts": "4.3.1",\n "@openzeppelin/test-helpers": "0.5.6",\n "@openzeppelin/contracts-upgradeable": "4.3.1",\n```\n | medium |
```\nfunction \_convert(address token, uint256 amount, uint8 resolution, bool to) private view returns (uint256 converted) {\n uint8 decimals = IERC20(token).decimals();\n uint256 diff = 0;\n uint256 factor = 0;\n converted = 0;\n if (decimals > resolution) {\n diff = uint256(decimals.sub(resolution));\n factor = 10 \*\* diff;\n if (to && amount >= factor) {\n converted = amount.div(factor);\n } else if (!to) {\n converted = amount.mul(factor);\n }\n } else if (decimals < resolution) {\n diff = uint256(resolution.sub(decimals));\n factor = 10 \*\* diff;\n if (to) {\n converted = amount.mul(factor);\n } else if (!to && amount >= factor) {\n converted = amount.div(factor);\n }\n }\n}\n```\n | high |
```\n if (entitledShares > queue[index].assets) {\n // skip the rollover for the user if the assets cannot cover the relayer fee instead of revert.\n if (queue[index].assets < relayerFee) {\n index++;\n continue;\n }\n```\n | medium |
```\nif (!version.valid) context.latestPosition.local.invalidate(newPosition);\nnewPosition.adjust(context.latestPosition.local);\n// rest of code\ncontext.latestPosition.local.update(newPosition);\n```\n | medium |
```\nfunction getAccountDividendsInfo(address account) external view returns (address, int256, int256, uint256,\n uint256, uint256) {\n return dividendTracker.getAccount(account);\n}\n```\n | none |
```\nfunction \_beforeTokenTransfer(address from, address to, uint256 amount) internal override {\n uint256 balanceFrom = (from != address(0)) ? balanceOf(from) : 0;\n uint256 balanceTo = (from != address(0)) ? balanceOf(to) : 0;\n uint256 newTotalSupply = totalSupply()\n .add(from == address(0) ? amount : 0)\n .sub(to == address(0) ? amount : 0);\n\n ParamsHelper memory params = ParamsHelper({\n from: from,\n to: to,\n amount: amount,\n balanceFrom: balanceFrom,\n balanceTo: balanceTo,\n newTotalSupply: newTotalSupply\n });\n```\n | medium |
```\nfunction getMarketCap() external view returns (uint256) {\n return (getCirculatingSupply() * calculatePrice() * getBNBPrice());\n}\n```\n | none |
```\n/// @notice read the oracle price\n/// @return oracle price\n/// @return true if price is valid\nfunction read() external view override returns (Decimal.D256 memory, bool) {\n (uint80 roundId, int256 price,,, uint80 answeredInRound) = chainlinkOracle.latestRoundData();\n bool valid = !paused() && price > 0 && answeredInRound == roundId;\n\n Decimal.D256 memory value = Decimal.from(uint256(price)).div(oracleDecimalsNormalizer);\n return (value, valid);\n}\n```\n | medium |
```\nfunction repayBorrow(uint256 repayAmount) external returns (uint256);\n```\n | high |
```\nif (\_globalFee > BASIS\_POINTS) {\n revert InvalidFee();\n}\nStakingContractStorageLib.setGlobalFee(\_globalFee);\nif (\_operatorFee > BASIS\_POINTS) {\n revert InvalidFee();\n}\nStakingContractStorageLib.setOperatorFee(\_operatorFee);\n```\n | low |
```\nfunction updateTokenURI(string memory newuri)\n external\n onlyOwner\n returns (bool)\n{\n _setURI(newuri);\n emit NewURI(newuri, msg.sender);\n return true;\n}\n```\n | none |
```\nfunction startTrading() external onlyOwner {\n tradingEnabled = true;\n swapbackEnabled = true;\n emit TradingEnabled(block.timestamp);\n}\n```\n | none |
```\n uint256 _pool = balance();\n if (_pool + _amount > underlyingCap) {\n revert NYProfitTakingVault__UnderlyingCapReached(underlyingCap);\n }\n uint256 _before = underlying.balanceOf(address(this));\n underlying.safeTransferFrom(msg.sender, address(this), _amount);\n uint256 _after = underlying.balanceOf(address(this));\n _amount = _after - _before;\n```\n | low |
```\n function liquidate(\n address _account,\n uint256 _debtAmount,\n uint256 _minExchangeRate\n ) external onlyLiquidator whenNotPaused updateReward(_account) returns (bool) {\n if (_debtAmount == 0) revert wrongLiquidationAmount();\n\n UserDetails memory accDetails = userDetails[_account];\n\n // Since Taurus accounts' debt continuously decreases, liquidators may pass in an arbitrarily large number in order to\n // request to liquidate the entire account.\n if (_debtAmount > accDetails.debt) {\n _debtAmount = accDetails.debt;\n }\n\n // Get total fee charged to the user for this liquidation. Collateral equal to (liquidated taurus debt value * feeMultiplier) will be deducted from the user's account.\n // This call reverts if the account is healthy or if the liquidation amount is too large.\n (uint256 collateralToLiquidate, uint256 liquidationSurcharge) = _calcLiquidation(\n accDetails.collateral,\n accDetails.debt,\n _debtAmount\n );\n```\n | medium |
```\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 |
```\nfunction _stakeToken(uint _tokenId, uint _unlockTime) internal returns (uint) {\n if (_unlockTime > 0) {\n unlockTime[_tokenId] = _unlockTime;\n uint fullStakedTimeBonus = ((_unlockTime - block.timestamp) * stakingSettings.maxStakeBonusAmount) / stakingSettings.maxStakeBonusTime;\n stakedTimeBonus[_tokenId] = _tokenId < 10000 ? fullStakedTimeBonus : fullStakedTimeBonus / 2;\n }\n```\n | medium |
Subsets and Splits