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, ... | 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 \*/\... | 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... | 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.removeL... | 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 memo... | 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 ... | 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... | 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, upn... | 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 = marketingB... | none |
```\n (\n netPnLE36,\n lenderProfitUSDValueE36,\n borrowTotalUSDValueE36,\n positionOpenUSDValueE36,\n sharingProfitTokenAmts ) = calcProfitInfo(_positionManager, _user, _posId);\n // 2. add liquidation premium to the shared profi... | 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 ... | 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 + bal... | 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(t... | 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... | 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 /// Thi... | 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... | 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 (_fr... | 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 = inte... | 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 yI... | 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 subAccoun... | 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 ... | 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[policyInde... | 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 minimumToke... | 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.swapExactT... | 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 up... | 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 = \_lastEp... | 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 contrac... | 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(Wi... | 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\... | 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 addr... | 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()... | 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 ... | 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 /... | 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 / ownva... | 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... | 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(... | 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) = \_capFeeAmou... | 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 tra... | 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 = \_tokensToWit... | 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 ... | 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(resoluti... | 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 ... | 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) ? amoun... | 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 &... | 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 ... | 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 = userDeta... | 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... | 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[_token... | medium |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.