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) {\n nftType = NFTTypes.CRYPTOKITTIES;\n}\n// All other NFTs that support the EIP721 standard\nelse {\n // Here 0x80ac58cd is the ERC721 interface Id\n // Neither a standard NFT nor a non-standard supported NFT(punk, kitty or fighter)\n try IERC165(collateral_).supportsInterface(0x80ac58cd) returns (bool supportsERC721Interface) {\n if (!supportsERC721Interface) revert NFTNotSupported();\n } catch {\n revert NFTNotSupported();\n }\n\n nftType = NFTTypes.STANDARD_ERC721;\n}\n```\n | 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```\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(account)\n }\n return size > 0;\n}\n```\n | 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.AddressSet)) private _localCallbacks;\n```\n | 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 uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());\n uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);\n swapEnabled = true;\n cooldownEnabled = true;\n _maxTxAmount = 50000000000000000 * 10**9;\n tradingOpen = true;\n IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);\n}\n```\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 - createFeeDiscount, FEE_DECIMALS);\n rewards[_protocol][underlying_] += feeAmount;\n\n // Mint new bond tokens\n bondToken.mint(msg.sender, amount_ - feeAmount);\n\n return (bondToken, amount_ - feeAmount);\n } else {\n // Mint new bond tokens\n bondToken.mint(msg.sender, amount_);\n\n return (bondToken, amount_);\n }\n```\n | 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) {\n // Make sure the access is permitted to only contracts in our Dapp\n require(boolStorage[keccak256(abi.encodePacked("contract.exists", msg.sender))], "Invalid or outdated network contract");\n }\n \_;\n}\n```\n | 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]).safeTransfer(\n address(harvester),\n balance\n );\n }\n}\n\n// convert all rewards to WETH\nharvester.harvest();\n```\n | 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)) {\n IDAOfiV1Factory(factory).createPair(\n address(this),\n lp.tokenBase,\n lp.tokenQuote,\n msg.sender,\n lp.slopeNumerator,\n lp.n,\n lp.fee\n );\n }\n address pair = DAOfiV1Library.pairFor(\n factory, lp.tokenBase, lp.tokenQuote, lp.slopeNumerator, lp.n, lp.fee\n );\n\n TransferHelper.safeTransferFrom(lp.tokenBase, lp.sender, pair, lp.amountBase);\n TransferHelper.safeTransferFrom(lp.tokenQuote, lp.sender, pair, lp.amountQuote);\n amountBase = IDAOfiV1Pair(pair).deposit(lp.to);\n}\n```\n | 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 );\n _mintingBeneficiary = payable(beneficiary);\n}\n```\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 = \_sushiAddr;\n }\n```\n | 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 which is combined asset amount for both tokens\n assets = new address[](1);\n amounts = new uint256[](1);\n\n assets[0] = address(state.usdc);\n amounts[0] = (btcAssetAmount + ethAssetAmount);\n } else if (btcAssetAmount == 0 || ethAssetAmount == 0) {\n // Exactly one would be true since case-1 excluded (both false) | case-2\n // One token amount = 0 and other token amount > 0\n // only one entry required for the non-zero amount token\n assets = new address[](1);\n amounts = new uint256[](1);\n\n if (btcAssetAmount == 0) {\n assets[0] = (repayDebtBtc ? address(state.usdc) : address(state.wbtc));\n amounts[0] = btcAssetAmount;\n } else {\n assets[0] = (repayDebtEth ? address(state.usdc) : address(state.weth));\n amounts[0] = ethAssetAmount;\n }\n```\n | 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.length / PUBLIC\_KEY\_LENGTH != \_keyCount) {\n revert InvalidPublicKeys();\n }\n```\n | 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;\n uint8 constant internal INTERNAL_TOKEN_DECIMALS = 8;\n \n ..SNIP..\n \n // Storage gap for future potential upgrades\n uint256[45] private __gap;\n }\n```\n | 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 // remove from assets list if this was the last vault for that asset\n if (_vaultsByAsset[asset].length() == 1) {\n //slither-disable-next-line unused-return\n _assets.remove(asset);\n }\n\n // remove from vaultsByAsset mapping\n if (!_vaultsByAsset[asset].remove(vaultAddress)) revert VaultNotFound(vaultAddress);\n\n emit VaultRemoved(asset, vaultAddress);\n }\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, UFixed18 calldataFee) = (\n _baseFee(applicableGas, config.multiplierBase, config.bufferBase),\n _calldataFee(applicableCalldata, config.multiplierCalldata, config.bufferCalldata)\n );\n\n\n UFixed18 keeperFee = UFixed18.wrap(applicableValue).add(baseFee).add(calldataFee).mul(_etherPrice());\n _raiseKeeperFee(keeperFee, data);\n keeperToken().push(msg.sender, keeperFee);\n\n\n emit KeeperCall(msg.sender, applicableGas, applicableValue, baseFee, calldataFee, keeperFee);\n }\n```\n | 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(payable(profile.anchor));\n\n console.log("registry address: %s", address(registry()));\n console.log("anchor address: %s", profile.anchor);\n console.log("anchor.registry: %s", address(_anchor.registry()));\n\n emit log_named_bytes32("profile.id", profile.id);\n emit log_named_bytes32("anchor.profile.id", _anchor.profileId());\n\n Anchor _anchor_proxy = Anchor(payable(address( _anchor.registry())));\n assertEq(address(registry()),address(_anchor.registry()) ,"wrong anchor registry");\n }\n```\n | 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), "ST17");\n require(hasRole(DEFAULT\_ADMIN\_ROLE, \_msgSender()), "ST2");\n \_rewardRate.push(rewardRate);\n \_lastMovingRewardTimestamp.push(block.timestamp);\n emit SetRewardRate(rewardRate);\n\n return true;\n}\n```\n | 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 totalContracts = await auction.getTotalContracts(epoch);\n await auction.addLimitOrder(\n epoch,\n fixedFromFloat(params.price.max),\n totalContracts.mul(2)\n );\n\n await auction.addLimitOrder(\n epoch,\n fixedFromFloat(params.price.max),\n totalContracts.div(2)\n );\n\n const epochByBuyer = await auction.getEpochsByBuyer(addresses.buyer1);\n\n assert.equal(epochByBuyer.length, 1);\n assert.bnEqual(epochByBuyer[0], epoch);\n \n await expect(auction.callStatic[\n "previewWithdraw(uint64)"\n ](epoch)).to.be.reverted;\n });\n```\n | 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() != stableAddress) {\n (Res1, Res0, ) = pair.getReserves();\n }\n uint256 res0 = Res0 * 10**token1.decimals();\n return (res0 / Res1); // return amount of token0 needed to buy token1\n}\n```\n | 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).isCoolerCallback()) revert NotCoolerCallback();\n\n // Ensure loan request is active. \n if (!req.active) revert Deactivated();\n\n // Clear the loan request in memory.\n req.active = false;\n\n // Calculate and store loan terms.\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 loanID = loans.length;\n loans.push(\n Loan({\n request: req,\n amount: req.amount + interest,\n unclaimed: 0,\n collateral: collat,\n expiry: expiration,\n lender: msg.sender,\n repayDirect: repayDirect_,\n callback: isCallback_\n })\n );\n\n // Clear the loan request storage.\n requests[reqID_].active = false;\n\n // Transfer debt tokens to the owner of the request.\n debt().safeTransferFrom(msg.sender, owner(), req.amount);\n\n // Log the event.\n factory().newEvent(reqID_, CoolerFactory.Events.ClearRequest, 0);\n}\n```\n | 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 / xABR.totalSupply();\n\n uint256 result = (amount * BP) / (userShareBP + (BP * BP / baseFeeRateBP));\n if (_minFee > 0 && result < _minFee) {\n return _minFee;\n } else {\n return result;\n }\n}\n```\n | 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 tokenId) internal virtual {\n```\n | 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]) /\n supplyCheckpoints[getPriorSupplyIndex(_lastEpochEnd)].supply;\n```\n | 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 = milestones[upcomingMilestone];\n Recipient memory recipient = _recipients[acceptedRecipientId];\n\n if (recipient.proposalBid > poolAmount) revert NOT_ENOUGH_FUNDS();\n\n uint256 amount = (recipient.proposalBid * milestone.amountPercentage) / 1e18;\n\n poolAmount -= amount;//<@@ NOTICE the poolAmount get decrease over time\n\n _transferAmount(pool.token, recipient.recipientAddress, amount);\n\n // rest of code\n }\n```\n | 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 == QuoteStatus.OPENED, "PartyBFacet: Invalid state");\n..SNIP..\n```\n | 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 * _secondsFromLastCollection) / SAFE_MULTIPLIER;\n }\n```\n | 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";\nimport { GMXTypes } from "../../../contracts/strategy/gmx/GMXTypes.sol";\nimport { GMXTestHelper } from "./GMXTestHelper.sol";\n\nimport { IDeposit } from "../../../contracts/interfaces/protocols/gmx/IDeposit.sol";\nimport { IEvent } from "../../../contracts/interfaces/protocols/gmx/IEvent.sol";\n\ncontract GMXDepositTest is GMXMockVaultSetup, GMXTestHelper, TestUtils {\n function test_POC2() public {\n uint256 lpAmtUser1 = 0.000005e18; //~400$ (because price of lpToken = 79990000$)\n\n //In the setup, the owner receives a few lpTokens, which are now sent to user1 for testing the token injection\n vm.startPrank(owner);\n IERC20(address(WETHUSDCpair)).transfer(address(user1), lpAmtUser1);\n vm.stopPrank();\n \n //Owner deposits in Vault\n vm.startPrank(owner);\n _createDeposit(address(WETH), 10 ether, 0, SLIPPAGE, EXECUTION_FEE);\n vm.stopPrank();\n mockExchangeRouter.executeDeposit(address(WETH), address(USDC), address(vault), address(callback));\n\n //Variable for Assertion\n (,uint256 debtAmtTokenBBefore) = vault.debtAmt();\n\n vm.startPrank(user1);\n _createDeposit(address(WETH), 0.1 ether, 0, SLIPPAGE, EXECUTION_FEE); //User1 creates deposit. The 0.1 ether is being leveraged\n IERC20(address(WETHUSDCpair)).transfer(address(vault), lpAmtUser1); //User1 injects lp-tokens between createDeposit and processDeposit. They are not leveraged\n vm.stopPrank();\n //In step one, the equity was saved before the deposit. The equity depends on the LP amount and the debts to the lending Vaults. In step two, \n //the saved equity is used alongside the current equity to calculate how many Vault shares a user receives. This way, user1 receives shares \n //for their injected tokens that do not have any leverage.(so no borrowing from the lending vaults was done for these tokens)\n mockExchangeRouter.executeDeposit(address(WETH), address(USDC), address(vault), address(callback));\n \n //User1 withdraws all his tokens.\n uint256 vaultSharesAmount = IERC20(address(vault)).balanceOf(user1);\n vm.startPrank(user1);\n //In the case of a withdrawal, the debts to the LendingVaults are also repaid. Since it is assumed that all tokens have been leveraged, there \n //is a mistaken repayment to the lending vaults for the injected tokens as well.\n _createAndExecuteWithdrawal(address(WETH), address(USDC), address(USDC), vaultSharesAmount, 0, SLIPPAGE, EXECUTION_FEE);\n vm.stopPrank();\n\n //Variable for Assertion\n (,uint256 debtAmtTokenBAfter) = vault.debtAmt();\n \n //After User1 withdrew their LP tokens, the debt amount for TokenB would normally be approximately the same as it was before User1 deposited. \n //However, due to the unleveraged tokens, more debt was repaid, resulting in a lower debt and, consequently, lower leverage than before.\n assert(debtAmtTokenBBefore - 750e6 > debtAmtTokenBAfter); //750e6 == $750. This is to show that the debt is significantly less than before\n\n console.log("debtAmtTokenBBefore: %s", debtAmtTokenBBefore);\n console.log("debtAmtTokenBAfter: %s", debtAmtTokenBAfter);\n }\n}\n```\n | 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[_target];\n _automatedMarketMakerPairs = automatedMarketMakerPairs[_target];\n}\n```\n | 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 bridgedToNativeToken[bridgedToken] = \_nativeToken;\n nativeToBridgedToken[\_nativeToken] = bridgedToken;\n }\n BridgedToken(bridgedToken).mint(\_recipient, \_amount);\n}\n```\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 rocketNodeStaking.slashRPL(nodeAddress, slashAmount);\n // Record slashing\n slashed = true;\n}\n```\n | 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 timestamp = feeder.latestTimestamp();\n}\n```\n | 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 || agentId == 0) revert Unauthorized();\n // deploy a new instance of Agent with the same ID and auth\n newAgent = GetRoute.agentDeployer(router).deploy(\n router,\n agentId,\n owner,\n IAuth(address(oldAgent)).operator()\n );\n // Register the new agent and unregister the old agent\n agents[newAgent] = agentId;\n // transfer funds from old agent to new agent and mark old agent as decommissioning\n oldAgent.decommissionAgent(newAgent);\n // delete the old agent from the registry\n agents[agent] = 0;\n}\n```\n | 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 uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())\n .createPair(address(this), _uniswapV2Router.WETH());\n\n // set the rest of the contract variables\n uniswapV2Router = _uniswapV2Router;\n \n //exclude owner and this contract from fee\n _isExcludedFromFee[owner()] = true;\n _isExcludedFromFee[address(this)] = true;\n _isExcludedFromFee[_deadAddress] = true;\n \n // exclude dead address from reward\n _isExcluded[_deadAddress] = true;\n\n // enable 24hr sales tax to protect from bots\n toggleSalesTax(true);\n \n emit Transfer(address(0), _msgSender(), _tTotal);\n}\n```\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."\n);\n```\n | 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 uint256 i = \_counter;\n i < \_unstakingExpirationLength;\n i = i.add(1)\n ) {\n //get getUnstakeTime and compare it with current timestamp to check if 21 days + epoch difference has passed\n (uint256 \_getUnstakeTime, , ) = getUnstakeTime(\n \_unstakingExpiration[staker][i]\n );\n if (block.timestamp >= \_getUnstakeTime) {\n //if 21 days + epoch difference has passed, then add the balance and then mint uTokens\n \_withdrawBalance = \_withdrawBalance.add(\n \_unstakingAmount[staker][i]\n );\n \_unstakingExpiration[staker][i] = 0;\n \_unstakingAmount[staker][i] = 0;\n \_withdrawCounters[staker] = \_withdrawCounters[staker].add(1);\n }\n }\n\n require(\_withdrawBalance > 0, "LQ21");\n emit WithdrawUnstakeTokens(staker, \_withdrawBalance, block.timestamp);\n \_uTokens.mint(staker, \_withdrawBalance);\n}\n```\n | 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 amount, address[] memory misbehavedOperators)\n public\n onlyApprovedOperatorContract(msg.sender) {\n for (uint i = 0; i < misbehavedOperators.length; i++) {\n address operator = misbehavedOperators[i];\n require(authorizations[msg.sender][operator], "Not authorized");\n operators[operator].amount = operators[operator].amount.sub(amount);\n }\n\n token.burn(misbehavedOperators.length.mul(amount));\n}\n\n/\*\*\n \* @dev Seize provided token amount from every member in the misbehaved\n \* operators array. The tattletale is rewarded with 5% of the total seized\n \* amount scaled by the reward adjustment parameter and the rest 95% is burned.\n \* @param amount Token amount to seize from every misbehaved operator.\n \* @param rewardMultiplier Reward adjustment in percentage. Min 1% and 100% max.\n \* @param tattletale Address to receive the 5% reward.\n \* @param misbehavedOperators Array of addresses to seize the tokens from.\n \*/\nfunction seize(\n uint256 amount,\n uint256 rewardMultiplier,\n address tattletale,\n address[] memory misbehavedOperators\n) public onlyApprovedOperatorContract(msg.sender) {\n for (uint i = 0; i < misbehavedOperators.length; i++) {\n address operator = misbehavedOperators[i];\n require(authorizations[msg.sender][operator], "Not authorized");\n operators[operator].amount = operators[operator].amount.sub(amount);\n }\n\n uint256 total = misbehavedOperators.length.mul(amount);\n uint256 tattletaleReward = (total.mul(5).div(100)).mul(rewardMultiplier).div(100);\n\n token.transfer(tattletale, tattletaleReward);\n token.burn(total.sub(tattletaleReward));\n}\n```\n | 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] = Arithmetic.overflowResistantFraction(amtIn, \n balances[i], balances[indexOfReferenceToken]);\n }\n }\n```\n | 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 uint8(i),\n paymentAmount,\n address(msg.sender)\n );\n paymentAmount -= capitalSpent;\n }\n}\n```\n | 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 normal share mint is round down\n shares = _convertToShares(fees, Math.Rounding.Up);\n _mint(sink, shares);\n emit Deposit(address(this), sink, fees, shares);\n }\n```\n | 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 is not the owner of the Agent or the beneficiary, revert\n if(\n !(benneficiaryAddress == sender || (IAuth(msg.sender).owner() == sender && recipient == benneficiaryAddress) )) {\n revert Unauthorized();\n }\n (\n beneficiary,\n amount\n ) = beneficiary.withdraw(proposedAmount);\n // update the beneficiary in storage\n \_agentBeneficiaries[agentID] = beneficiary;\n}\n```\n | 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 MaxWalletSizeUpdated(_maxWalletSize);\n}\n```\n | 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.longOpenInterest;\n cache.fundingUsdForShortCollateral = cache.fundingUsd * cache.oi.longOpenInterestWithShortCollateral / cache.oi.longOpenInterest;\n } else {\n cache.fundingUsdForLongCollateral = cache.fundingUsd * cache.oi.shortOpenInterestWithLongCollateral / cache.oi.shortOpenInterest;\n cache.fundingUsdForShortCollateral = cache.fundingUsd * cache.oi.shortOpenInterestWithShortCollateral / cache.oi.shortOpenInterest;\n }\n```\n | 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 }\n emit UpdateGlobalParameter(key, value);\n}\n```\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 _tokenIds++;\n\n if (dutchAuctionLastPrice != msg.value)\n revert InvalidBuyNFTPrice(dutchAuctionLastPrice, msg.value);\n\n if (pixelMintWhitelistedAddresses[msg.sender] != 0)\n revert WhitelistedAddressAlreadyClaimedNFT();\n\n bytes32 leaf = keccak256(abi.encodePacked(msg.sender));\n\n if (\n !MerkleProof.verify(\n _merkleProof,\n merkleRootOfPixelMintWhitelistAddresses,\n leaf\n )\n ) revert InvalidMerkleProof();\n\n pixelMintWhitelistedAddresses[msg.sender] = 1;\n\n emit NewNFTMintedOnPixelSale(_tokenIds, msg.sender, msg.value);\n\n _mint(msg.sender, _tokenIds, 1, "");\n\n return true;\n } else {\n revert UnAuthorizedRequest();\n }\n}\n```\n | none |
Subsets and Splits