function stringlengths 12 63.3k | severity stringclasses 4
values |
|---|---|
```\nNFTTypes nftType;\n// CryptoPunks NFTs\nif (collateral_ == 0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB ) {\n nftType = NFTTypes.CRYPTOPUNKS;\n}\n// CryptoKitties and CryptoFighters NFTs\nelse if (collateral_ == 0x06012c8cf97BEaD5deAe237070F9587f8E7A266d || collateral_ == 0x87d598064c736dd0C712D329aFCFAA0Ccc1921A1)... | medium |
```\n// Remove the line below\n uint24 internal constant _MIN_BID_PERCENT = 1000; // 1%\n// Add the line below\n uint24 internal constant _MIN_BID_PERCENT = 100; // 0.1%\n```\n | medium |
```\n if (s.asset[asset].orderId < 65000) {\n revert Errors.OrderIdCountTooLow();\n }\n```\n | low |
```\nfunction isValidSigner(address _account) public view override returns (bool valid) {\n valid = HATS.isWearerOfHat(_account, signersHatId);\n}\n```\n | medium |
```\nif (contractEthBalance > 1) {\n if (\_wasFraud) {\n initiator.transfer(contractEthBalance);\n } else {\n // There will always be a liquidation initiator.\n uint256 split = contractEthBalance.div(2);\n \_d.pushFundsToKeepGroup(split);\n initiator.transfer(split);\n }\n}\n... | low |
```\n(address[] memory modules,) = GnosisSafe(payable(_safe)).getModulesPaginated(SENTINEL_MODULES, 5);\nuint256 existingModuleCount = modules.length;\n```\n | medium |
```\nfunction transferControl(address split, address newController)\n external\n override\n onlySplitController(split)\n validNewController(newController)\n{\n splits[split].newPotentialController = newController;\n emit InitiateControlTransfer(split, newController);\n}\n```\n | none |
```\nif (calcBase.mul(submissionCount).div(rocketDAONodeTrusted.getMemberCount()) >= rocketDAOProtocolSettingsNetwork.getNodeConsensusThreshold()) {\n setMinipoolWithdrawable(\_minipoolAddress, \_stakingStartBalance, \_stakingEndBalance);\n}\n```\n | medium |
```\nfunction isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize, which returns 0 for contracts in\n // construction, since the code is only stored at the end of the\n // constructor execution.\n\n uint256 size;\n assembly {\n size := extcodesize(acco... | none |
```\n/// @dev Mapping from version to a set of registered markets for settlement callback\nmapping(uint256 => EnumerableSet.AddressSet) private _globalCallbacks;\n\n/// @dev Mapping from version and market to a set of registered accounts for settlement callback\nmapping(uint256 => mapping(IMarket => EnumerableSet.Addre... | medium |
```\nfunction openTrading() external onlyOwner() {\n require(!tradingOpen,"trading is already open");\n IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);\n uniswapV2Router = _uniswapV2Router;\n _approve(address(this), address(uniswapV2Router), _tTotal);\n ... | none |
```\nuint256 bptTotal = pool.totalSupply();\nuint256 bptBalance = pool.balanceOf(address(this));\n\n// Balancer locks a small amount of bptTotal after init, so 0 bpt means pool needs initializing\nif (bptTotal == 0) {\n \_initializePool();\n return;\n}\n```\n | low |
```\nFile: BondFixedExpiryTeller.sol\n // If fee is greater than the create discount, then calculate the fee and store it\n // Otherwise, fee is zero.\n if (protocolFee > createFeeDiscount) {\n // Calculate fee amount\n uint256 feeAmount = amount_.mulDiv(protocolFee - createFe... | medium |
```\nmodifier onlyLatestRocketNetworkContract() {\n // The owner and other contracts are only allowed to set the storage upon deployment to register the initial contracts/settings, afterwards their direct access is disabled\n if (boolStorage[keccak256(abi.encodePacked("contract.storage.initialised"))] == true) {\... | high |
```\n// get list of tokens to transfer to harvester\naddress[] memory rewardTokens = harvester.rewardTokens();\n//transfer them\nuint256 balance;\nfor (uint256 i = 0; i < rewardTokens.length; i++) {\n balance = IERC20(rewardTokens[i]).balanceOf(address(this));\n\n if (balance > 0) {\n IERC20(rewardTokens[i... | medium |
```\nfunction addLiquidity(\n LiquidityParams calldata lp,\n uint deadline\n) external override ensure(deadline) returns (uint256 amountBase) {\n if (IDAOfiV1Factory(factory).getPair(\n lp.tokenBase,\n lp.tokenQuote,\n lp.slopeNumerator,\n lp.n,\n lp.fee\n ) == address(0))... | high |
```\nfunction changeMintBeneficiary(address beneficiary) public onlyOwner {\n require(\n beneficiary != address(0),\n "DCBW721: Minting beneficiary cannot be address 0"\n );\n require(\n beneficiary != _mintingBeneficiary,\n "DCBW721: beneficiary cannot be same as previous"\n );\... | none |
```\ncontract SushiYieldSource is IYieldSource {\n using SafeMath for uint256;\n address public sushiBar;\n address public sushiAddr;\n mapping(address => uint256) public balances;\n\n constructor(address \_sushiBar, address \_sushiAddr) public {\n sushiBar = \_sushiBar;\n sushiAddr = \_sus... | low |
```\n // If both eth and btc swap amounts are not beyond the threshold then no flashloan needs to be executed | case 1\n if (btcAssetAmount == 0 && ethAssetAmount == 0) return;\n\n if (repayDebtBtc && repayDebtEth) {\n // case where both the token assets are USDC\n // only one entry required whic... | high |
```\nfunction toShortString(string memory str) internal pure returns (ShortString) {\n bytes memory bstr = bytes(str);\n if (bstr.length > 31) {\n revert StringTooLong(str);\n }\n return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));\n}\n```\n | none |
```\n uint256 amountOut; //amount received by trade\n bool stablePool; //if the traded pool is stable or volatile.\n (amountOut, stablePool) = router.getAmountOut(HUNDRED_TOKENS, token1, USDC);\n require(stablePool == stable, "pricing occuring through wrong pool" );\n```\n | high |
```\nFile: TellerV2.sol\n\n if (bidDefaultDuration[_bidId] == 0) return false;\n```\n | medium |
```\nfunction getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := store.slot\n }\n}\n```\n | none |
```\nfunction addValidators(\n uint256 \_operatorIndex,\n uint256 \_keyCount,\n bytes calldata \_publicKeys,\n bytes calldata \_signatures\n) external onlyActiveOperator(\_operatorIndex) {\n if (\_keyCount == 0) {\n revert InvalidArgument();\n }\n\n if (\_publicKeys.length % PUBLIC\_KEY\_LENGTH != 0 || \_publicKeys.len... | medium |
```\nfunction withdrawStuckETH() external onlyOwner {\n uint256 balance = address(this).balance;\n require(balance > 0, "No ETH available to withdraw");\n\n (bool success, ) = address(msg.sender).call{value: balance}("");\n require(success, "transferring ETH failed");\n}\n```\n | none |
```\nabstract contract BaseStrategyVault is Initializable, IStrategyVault {\n using TokenUtils for IERC20;\n using TradeHandler for Trade;\n\n /// @notice Hardcoded on the implementation contract during deployment\n NotionalProxy public immutable NOTIONAL;\n ITradingModule public immutable TRADING_MODULE... | medium |
```\nfunction add(uint256 a, uint256 b) internal pure returns (uint256) {\n return a + b;\n}\n```\n | none |
```\n function removeVault(address vaultAddress) external onlyUpdater {\n Errors.verifyNotZero(vaultAddress, "vaultAddress");\n\n // remove from vaults list\n if (!_vaults.remove(vaultAddress)) revert VaultNotFound(vaultAddress);\n\n address asset = ILMPVault(vaultAddress).asset();\n\n ... | medium |
```\n modifier keep(\n KeepConfig memory config,\n bytes calldata applicableCalldata,\n uint256 applicableValue,\n bytes memory data\n ) {\n uint256 startGas = gasleft();\n\n\n _;\n\n\n uint256 applicableGas = startGas - gasleft();\n (UFixed18 baseFee, UFixe... | medium |
```\nlet l\_success := staticcall(sub(gas(), 2000),8,mPtr,0x180,0x00,0x20)\n// l\_success := true\nmstore(add(state, state\_success), and(l\_success,mload(add(state, state\_success))))\n```\n | high |
```\nOHM token balance: 100_000\nwstETH token balance: 1_000\nTotal LP: 10_000\n```\n | medium |
```\n function test_Audit_createProfile() public {\n // create profile\n bytes32 newProfileId = registry().createProfile(nonce, name, metadata, profile1_owner(), profile1_members());\n Registry.Profile memory profile = registry().getProfileById(newProfileId);\n Anchor _anchor = Anchor(pay... | high |
```\nfunction submitData(\n SubmissionData calldata \_submissionData\n)\n external\n whenTypeNotPaused(PROVING\_SYSTEM\_PAUSE\_TYPE)\n whenTypeNotPaused(GENERAL\_PAUSE\_TYPE)\n onlyRole(OPERATOR\_ROLE)\n{\n \_submitData(\_submissionData);\n}\n```\n | medium |
```\nfunction setRewardRate(uint256 rewardRate)\n public\n virtual\n override\n returns (bool success)\n{\n // range checks for rewardRate. Since rewardRate cannot be more than 100%, the max cap\n // is \_valueDivisor \* 100, which then brings the fees to 100 (percentage)\n require(rewardRate <= \_valueDivisor.mul(100)... | medium |
```\n it("previewWithdraw reverts if buyer has too many contracts", async () => {\n assert.isEmpty(await auction.getEpochsByBuyer(addresses.buyer1));\n\n await asset\n .connect(signers.buyer1)\n .approve(addresses.auction, ethers.constants.MaxUint256);\n\n const totalCon... | high |
```\nfunction call(\n address to,\n uint256 value,\n bytes memory data,\n uint256 txGas\n) internal returns (bool success) {\n assembly {\n success := call(txGas, to, value, add(data, 0x20), mload(data), 0, 0)\n }\n}\n```\n | none |
```\nfunction getBNBPrice() public view returns (uint256) {\n IPancakePair pair = IPancakePair(stablePairAddress);\n IERC20 token1 = pair.token0() == stableAddress\n ? IERC20(pair.token1())\n : IERC20(pair.token0());\n\n (uint256 Res0, uint256 Res1, ) = pair.getReserves();\n\n if (pair.token0(... | none |
```\nfunction clearRequest(\n uint256 reqID_,\n bool repayDirect_,\n bool isCallback_\n) external returns (uint256 loanID) {\n Request memory req = requests[reqID_];\n\n // If necessary, ensure lender implements the CoolerCallback abstract.\n if (isCallback_ && !CoolerCallback(msg.sender).isCoolerCall... | high |
```\nfunction mulDecode(uint224 x, uint y) internal pure returns (uint) {\n return (x * y) >> RESOLUTION;\n}\n```\n | none |
```\nmodifier onlyTest() {\n```\n | low |
```\nfunction fee(address token, address sender, uint256 amount, bytes4) public view returns (uint256) {\n uint256 _minFee = minFee[token];\n if (xABR.totalSupply() == 0 || baseFeeRateBP == 0 || amount == 0) {\n return _minFee;\n }\n uint256 userShareBP = xABR.balanceOf(sender) * feeMultiplier * BP /... | none |
```\nfunction sub(uint256 a, uint256 b) internal pure returns (uint256) {\n return a - b;\n}\n```\n | none |
```\n/**\n * @dev Mints `tokenId` and transfers it to `to`.\n *\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\n *\n * Requirements:\n *\n * - `tokenId` must not exist.\n * - `to` cannot be the zero address.\n *\n * Emits a {Transfer} event.\n */\nfunction _mint(address to, uint256 ... | medium |
```\nfunction setAllowCustomTokens(bool allow) public onlyOwner {\n dividendTracker.setAllowCustomTokens(allow);\n}\n```\n | none |
```\nif (PublicVault(owner).timeToEpochEnd() <= COLLATERAL_TOKEN.auctionWindow())\n```\n | high |
```\nassembly {\n flag := mload(add(\_data, 32))\n}\nif (flag == CHANGE\_PARTITION\_FLAG) {\n assembly {\n toPartition := mload(add(\_data, 64))\n```\n | high |
```\nfunction getMarketCap(IERC20Token \_reserveToken)\n public\n view\n returns(uint256)\n{\n Reserve storage reserve = reserves[\_reserveToken];\n return reserveBalance(\_reserveToken).mul(1e6).div(reserve.weight);\n}\n```\n | low |
```\nfunction reduceWeight(IERC20Token \_reserveToken)\n public\n validReserve(\_reserveToken)\n ownerOnly\n{\n \_protected();\n```\n | high |
```\n Checkpoint memory cp = checkpoints[tokenId][_endIndex];\n uint _lastEpochStart = _bribeStart(cp.timestamp);\n uint _lastEpochEnd = _lastEpochStart + DURATION;\n if (block.timestamp > _lastEpochEnd) {\n reward += (cp.balanceOf * \n tokenRewardsPerEpoch[token][_lastEpochStart]) ... | high |
```\n function _distribute(address[] memory, bytes memory, address _sender)\n internal\n virtual\n override\n onlyInactivePool\n onlyPoolManager(_sender)\n {\n // rest of code\n\n IAllo.Pool memory pool = allo.getPool(poolId);\n Milestone storage milestone =... | medium |
```\n(bool success,) = recipient.call{value: amount, gas: 10_000}('');\nif (!success) {revert ETH_TRANSFER_FAILED();}\n```\n | medium |
```\nfunction setAuthorization(address address_, bool authorization) external onlyOwner {\n isAuthorized[address_] = authorization;\n}\n```\n | none |
```\n (bool success, bytes memory data) = withdrawal.usr.call{value: withdrawal.amount}("");\n if (success) {\n reserve -= withdrawal.amount;\n } else {\n emit WithdrawalFailed(withdrawal.usr, withdrawal.amount, data);\n }\n i += 1;\n```\n | high |
```\nFile: PartyBFacetImpl.sol\n function emergencyClosePosition(uint256 quoteId, PairUpnlAndPriceSig memory upnlSig) internal {\n AccountStorage.Layout storage accountLayout = AccountStorage.layout();\n Quote storage quote = QuoteStorage.layout().quotes[quoteId];\n require(quote.quoteStatus == ... | medium |
```\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 |
```\n //check swap value of 100tokens to USDC to protect against flash loan attacks\n uint256 amountOut; //amount received by trade\n bool stablePool; //if the traded pool is stable or volatile.\n (amountOut, stablePool) = router.getAmountOut(HUNDRED_TOKENS, token1, USDC);\n```\n | high |
```\nfunction pendingFee(GMXTypes.Store storage self) public view returns (uint256) {\n uint256 totalSupply_ = IERC20(address(self.vault)).totalSupply();\n uint256 _secondsFromLastCollection = block.timestamp - self.lastFeeCollected;\n return (totalSupply_ * self.feePerSecond * _secondsFromLastColl... | medium |
```\n NP_t = (1 + rate_s) * MOMP_s * TP_s * \frac{TP_s}{LUP_s} * \frac{BI_s}{BI_t}\n```\n | medium |
```\ndef _debt_interest_since_last_update(_debt_token: address) -> uint256:\n\n return (\n\n (block.timestamp - self.last_debt_update[_debt_token])* self._current_interest_per_second(_debt_token)\n * self.total_debt_amount[_debt_token]\n / PERCENTAGE_BASE \n / PRECISION\n )\n```\n | high |
```\nfunction decrement(Counter storage counter) internal {\n uint256 value = counter._value;\n require(value > 0, "Counter: decrement overflow");\n unchecked {\n counter._value = value - 1;\n }\n}\n```\n | none |
```\nuint256 fee = \_value.mul(buyFeePct).div(PCT\_BASE);\nuint256 value = \_value.sub(fee);\n\n// collect fee and collateral\nif (fee > 0) {\n \_transfer(\_buyer, beneficiary, \_collateral, fee);\n}\n\_transfer(\_buyer, address(reserve), \_collateral, value);\n```\n | medium |
```\namountsToBeneficiary = $oracle.getQuoteAmounts(quoteParams_);\n```\n | medium |
```\nfunction withdraw(uint256 amount) public {\n withdrawFromAccount(msg.sender, amount);\n}\n```\n | high |
```\n// SPDX-License-Identifier: MIT\npragma solidity 0.8.21;\nimport { console, console2 } from "forge-std/Test.sol";\nimport { TestUtils } from "../../helpers/TestUtils.sol";\nimport { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";\nimport { GMXMockVaultSetup } from "./GMXMockVaultSetup.t.sol";\nimpo... | medium |
```\nfunction canCallClaimFees()\n internal\n view\n returns (bool, address[] memory, address[] memory)\n{\n return (true, WETH, new address[](0));\n}\n```\n | medium |
```\nfunction div(uint256 a, uint256 b) internal pure returns (uint256) {\n return a / b;\n}\n```\n | none |
```\n// Emit token transfer\nemit TokenDeposited(contractKey, \_tokenAddress, \_amount, block.timestamp);\n// Done\nreturn true;\n```\n | low |
```\nfunction checkMappings(\n address _target\n)\n external\n view\n returns (\n bool _transferTaxExempt,\n bool _transferLimitExempt,\n bool _automatedMarketMakerPairs\n )\n{\n _transferTaxExempt = transferTaxExempt[_target];\n _transferLimitExempt = transferLimitExempt[_targ... | none |
```\nif (nativeMappingValue == NATIVE\_STATUS) {\n // Token is native on the local chain\n IERC20(\_nativeToken).safeTransfer(\_recipient, \_amount);\n} else {\n bridgedToken = nativeMappingValue;\n if (nativeMappingValue == EMPTY) {\n // New token\n bridgedToken = deployBridgedToken(\_nativeToken, \_tokenMetadata);\n ... | high |
```\nfunction toInt256Safe(uint256 a) internal pure returns (int256) {\n int256 b = int256(a);\n require(b >= 0);\n return b;\n}\n```\n | none |
```\nfunction \_slash() private {\n // Get contracts\n RocketNodeStakingInterface rocketNodeStaking = RocketNodeStakingInterface(getContractAddress("rocketNodeStaking"));\n // Slash required amount and reset storage value\n uint256 slashAmount = nodeSlashBalance;\n nodeSlashBalance = 0;\n rocketNodeSt... | high |
```\nFile: BondBaseSDA.sol\n function marketPrice(uint256 id_) public view override returns (uint256) {\n uint256 price = currentControlVariable(id_).mulDivUp(currentDebt(id_), markets[id_].scale);\n\n return (price > markets[id_].minPrice) ? price : markets[id_].minPrice;\n }\n```\n | medium |
```\nint256 public constant chainlinkDecimalsAdapter = 10\*\*10;\n\nconstructor(address \_feeder) public {\n feeder = IChainlinkFeeder(\_feeder);\n}\n\nfunction price() public view returns (uint256 newPrice, uint256 timestamp) {\n newPrice = (feeder.latestAnswer() \* chainlinkDecimalsAdapter).toUint256();\n ti... | medium |
```\nfunction upgradeAgent(\n address agent\n) external returns (address newAgent) {\n IAgent oldAgent = IAgent(agent);\n address owner = IAuth(address(oldAgent)).owner();\n uint256 agentId = agents[agent];\n // only the Agent's owner can upgrade, and only a registered agent can be upgraded\n if (owner != msg.sender ||... | medium |
```\nbool notUndelegated = block.number <= operator.undelegatedAt || operator.undelegatedAt == 0;\n\nif (isAuthorized && isActive && notUndelegated) {\n balance = operator.amount;\n}\n```\n | low |
```\nconstructor (address payable marketingWalletAddress) {\n \n _marketingWallet = marketingWalletAddress;\n\n _rOwned[_msgSender()] = _rTotal;\n \n IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); \n // Create a uniswap pair for this new token\n ... | none |
```\n// Verify \_extraData is a call to unqualifiedDepositToTbtc.\nbytes4 functionSignature;\nassembly { functionSignature := mload(add(\_extraData, 0x20)) }\nrequire(\n functionSignature == vendingMachine.unqualifiedDepositToTbtc.selector,\n "Bad \_extraData signature. Call must be to unqualifiedDepositToTbtc."\... | low |
```\nfinalUserAmount = finalToken.balanceOf(address(this)) - relayerFeeAmount;\n```\n | medium |
```\nfunction updateMaxTxnAmount(uint256 newNum) external onlyOwner {\n require(newNum >= (totalSupply() * 5 / 1000)/1e18, "Cannot set maxTransactionAmount lower than 0.5%");\n maxTransactionAmount = newNum * (10**18);\n}\n```\n | none |
```\nfunction withdrawUnstakedTokens(address staker)\n public\n virtual\n override\n whenNotPaused\n{\n require(staker == \_msgSender(), "LQ20");\n uint256 \_withdrawBalance;\n uint256 \_unstakingExpirationLength = \_unstakingExpiration[staker]\n .length;\n uint256 \_counter = \_withdrawCounters[staker];\n for (\n ui... | high |
```\n ICurvePool(pool).remove_liquidity_one_coin(\n amountPosRemove,\n int128(tokenIndex),\n 0\n );\n```\n | high |
```\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 |
```\n for (uint256 i = 0; i < balances.length; i++) {\n if (i == indexOfReferenceToken) {\n amtsNeeded[i] = amtIn;\n } else {\n // amtsNeeded[i] = (amtIn * balances[i]) / \n balances[indexOfReferenceToken];\n amtsNeeded[i] = Arith... | medium |
```\nemit ApprovalByPartition(\_partition, \_tokenHolder, \_spender, \_amount);\n```\n | medium |
```\nfunction _makePayment(uint256 collateralId, uint256 totalCapitalAvailable)\n internal\n{\n uint256[] memory openLiens = liens[collateralId];\n uint256 paymentAmount = totalCapitalAvailable;\n for (uint256 i = 0; i < openLiens.length; ++i) {\n uint256 capitalSpent = _payment(\n collateralId,\n uint... | medium |
```\nFile: LMPVault.sol\n profit = (currentNavPerShare - effectiveNavPerShareHighMark) * totalSupply;\n fees = profit.mulDiv(performanceFeeBps, (MAX_FEE_BPS ** 2), Math.Rounding.Up);\n if (fees > 0 && sink != address(0)) {\n // Calculated separate from other mints as norm... | high |
```\nfunction beneficiaryWithdrawable(\n address recipient,\n address sender,\n uint256 agentID,\n uint256 proposedAmount\n) external returns (\n uint256 amount\n) {\n AgentBeneficiary memory beneficiary = \_agentBeneficiaries[agentID];\n address benneficiaryAddress = beneficiary.active.beneficiary;\n // If the sender ... | high |
```\n uint256 userAmount = balanceOf(msg.sender);\n // - Underlying (Frontend ONLY)\n if (userAmount == 0) {\n user.amount = 0;\n } else {\n user.amount -= r;\n }\n```\n | medium |
```\nfunction exemptFromFees(address account, bool excluded) public onlyOwner {\n transferTaxExempt[account] = excluded;\n emit ExcludeFromFees(account, excluded);\n}\n```\n | none |
```\nfunction setMaxWalletSizePercent(uint256 maxWalletSizePercent) external onlyOwner() {\n _maxWalletSize = (_tTotal * maxWalletSizePercent) / (10**2);\n \n require(_maxWalletSize >= _minMaxWalletSize, "Max Wallet Size percent too low, must be greater than or equal to _minMaxWalletSize");\n emit MaxWalletSize... | none |
```\n function recover(address token, uint256 amount) external onlyOwner {\n if (Constants.ETH_ADDRESS == token) {\n (bool status,) = msg.sender.call{value: amount}("");\n require(status);\n } else {\n IERC20(token).transfer(msg.sender, amount);\n }\n }\n```\n | medium |
```\nfunction setReinvest(bool value) external {\n dividendTracker.setReinvest(msg.sender, value);\n}\n```\n | none |
```\nfunction maxMint(address) public view virtual returns (uint256) {\n return type(uint256).max;\n}\n```\n | medium |
```\nfunction processDividendTracker(uint256 gas) external {\n (uint256 iterations, uint256 claims, uint256 lastProcessedIndex) = dividendTracker.process(gas);\n emit ProcessedDividendTracker(iterations, claims, lastProcessedIndex, false, gas);\n}\n```\n | none |
```\nuint256 swETHAmount = wrap(msg.value).mul(_ethToSwETHRate()).unwrap();\n// @audit expanding this out\n// wrap(msg.value).mul(_ethToSwETHRate()).unwrap();\n// wrap(msg.value).mul(wrap(1 ether).div(_swETHToETHRate())).unwrap();\n```\n | low |
```\nFile: MarketUtils.sol\n\n cache.fundingUsd = (cache.sizeOfLargerSide / Precision.FLOAT_PRECISION) * cache.durationInSeconds * cache.fundingFactorPerSecond;\n\n if (result.longsPayShorts) {\n cache.fundingUsdForLongCollateral = cache.fundingUsd * cache.oi.longOpenInterestWithLongCollateral / cache.oi.lo... | medium |
```\n// additional data is generated in off-chain using the OneInch API which takes in\n// fromTokenAddress, toTokenAddress, amount, fromAddress, slippage, destReceiver, disableEstimate\n(bool success, bytes memory result) = ONEINCH\_AGGREGATOR.call(\n swapExtraData\n);\n```\n | medium |
```\nrequire(\_votesRequired > 0, "Proposal cannot have a 0 votes required to be successful");\n```\n | medium |
```\nfunction setGlobalParameter(bytes32 key, uint256 value) public onlyWhitelistAdmin {\n if (key == "withdrawalLockBlockCount") {\n withdrawalLockBlockCount = value;\n } else if (key == "brokerLockBlockCount") {\n brokerLockBlockCount = value;\n } else {\n revert("key not exists");\n ... | high |
```\nfunction pixelMintingSale(bytes32[] calldata _merkleProof)\n external\n payable\n returns (bool)\n{\n if (\n (block.timestamp >=\n defaultSaleStartTime + DEFAULT_INITIAL_PUBLIC_SALE) &&\n (block.timestamp < defaultSaleStartTime + DEFAULT_PIXELMINT_SALE)\n ) {\n _token... | none |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.