function stringlengths 12 7.23k | severity stringclasses 4
values |
|---|---|
```\n(address[] memory modules,) = safe.getModulesPaginated(SENTINEL_OWNERS, enabledModuleCount);\n_existingModulesHash = keccak256(abi.encode(modules));\n```\n | high |
```\nuint256 oldShare = pos.debtShareOf[debtToken];\n(uint256 amountPaid, uint256 share) = repayInternal(\n positionId,\n debtToken,\n amountCall\n);\n\nuint256 liqSize = (pos.collateralSize * share) / oldShare;\nuint256 uTokenSize = (pos.underlyingAmount * share) / oldShare;\nuint256 uVaultShare = (pos.underl... | high |
```\n function test_audit_frontrunFlagShort() public {\n address alice = makeAddr("Alice"); //Alice will front-run Bob's attempt to flag her short\n address aliceSecondAddr = makeAddr("AliceSecondAddr");\n address bob = makeAddr("Bob"); //Bob will try to flag Alice's short \n address randomUser = makeAddr("randomUs... | high |
```\nfunction _reflectFee(uint256 rFee, uint256 tFee) private {\n _rTotal = _rTotal.sub(rFee);\n _tFeeTotal = _tFeeTotal.add(tFee);\n}\n```\n | none |
```\nif (lockedUntil != 0 && lockedUntil <= now) {\n deposits[owner].withdrawalLockedUntil[token] = 0;\n\n address depositAccount = deposits[owner].account;\n uint256 depositValue;\n\n if (token == address(0)) {\n depositValue = depositAccount.balance;\n } else {\n depositValue = ERC20Token(token).balanceOf(depositAcco... | low |
```\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 |
```\nfunction withdraw(uint256 _amount) external {//@audit-info LSD token\n if (_amount == 0) revert InvalidAmount();\n IERC20Upgradeable(address(stakingPool)).safeTransferFrom(msg.sender, address(this), _amount);//@audit-info get LSD token from the user\n _withdraw(msg.sender, _amount);\n}\n```\n | medium |
```\nfunction \_startRotation(bytes32 schainIndex, uint nodeIndex) private {\n ConstantsHolder constants = ConstantsHolder(contractManager.getContract("ConstantsHolder"));\n rotations[schainIndex].nodeIndex = nodeIndex;\n rotations[schainIndex].newNodeIndex = nodeIndex;\n rotations[schainIndex].freezeUntil ... | medium |
```\nfunction clone(address implementation) internal returns (address instance) {\n assembly {\n let ptr := mload(0x40)\n mstore(\n ptr,\n 0x3d605d80600a3d3981f336603057343d52307f00000000000000000000000000\n )\n mstore(\n add(ptr, 0x13),\n 0x830d2d700a97af574b186c80d40429385d24241565b08... | none |
```\n function repay (uint256 loanID, uint256 repaid) external {\n Loan storage loan = loans[loanID];\n// rest of code\n debt.transferFrom(msg.sender, loan.lender, repaid); //***<------- lender in debt token's blocklist will revert , example :debt = usdc\n collateral.transfer(owner, decollater... | high |
```\n function _poolRepayAll(address pool, address token) internal {\n .\n .\n info.totalBorrows = info.totalBorrows - amount;\n info.balance = info.balance - amount; // amount should be added here\n .\n .\n }\n```\n | high |
```\nFile: BondBaseCallback.sol\n /* ========== WHITELISTING ========== */\n\n /// @inheritdoc IBondCallback\n function whitelist(address teller_, uint256 id_) external override onlyOwner {\n // Check that the market id is a valid, live market on the aggregator\n try _aggregator.isLive(id_) retur... | medium |
```\n function previewWithdraw(uint256 assets) public view virtual returns (uint256) {\n uint256 supply = totalSupply; // Saves an extra SLOAD if totalSupply is non-zero.\n\n return supply == 0 ? assets : assets.mulDivUp(supply, totalAssets());\n }\n```\n | medium |
```\nfunction updateSplit(\n address split,\n address[] calldata accounts,\n uint32[] calldata percentAllocations,\n uint32 distributorFee\n)\n external\n override\n onlySplitController(split)\n validSplit(accounts, percentAllocations, distributorFee)\n{\n _updateSplit(split, accounts, percentAllocations, dist... | none |
```\nfunction mul(uint256 a, uint256 b) internal pure returns (uint256) {\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) {\n return 0;... | none |
```\nfunction _updateReserves(uint256 reserves) internal {\n require(\n reserves <= address(this).balance.sub(_grandPrizePool),\n "DCBW721: Reserve-Balance Mismatch"\n );\n _reserves = reserves;\n}\n```\n | none |
```\nFile: contracts\OperatorTokenomics\SponsorshipPolicies\VoteKickPolicy.sol\n function _endVote(address target) internal {\n address flagger = flaggerAddress[target];\n bool flaggerIsGone = stakedWei[flagger] == 0;\n bool targetIsGone = stakedWei[target] == 0;\n uint reviewerCount = re... | 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 |
```\nfunction functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, "Address: low-level static call failed");\n}\n```\n | none |
```\n /// @notice Roll into the next Series if there isn't an active series and the cooldown period has elapsed.\n function roll() external {\n if (maturity != MATURITY_NOT_SET) revert RollWindowNotOpen();\n\n if (lastSettle == 0) {\n // If this is the first roll, lock some shares in by minting the... | medium |
```\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 |
```\nuint totalGenesisTribe = tribeBalance() - totalCommittedTribe;\n```\n | medium |
```\nfunction lockBase(\n uint128 lockId, \n address wrappedBaseTokenAddress, \n bytes32 recipient, \n bytes4 destination) external payable isActive {\n (, uint256 fee, TokenInfo memory tokenInfo) = _createLock(\n lockId,\n wrappedBaseTokenAddress,\n msg.value,\n recipient,\n ... | none |
```\n // rest of code\n pushFeedbackToVault(_chainId, _vault, _relayerFee);\n xTransfer(_asset, _amount, _vault, _chainId, _slippage, _relayerFee);\n // rest of code\n```\n | medium |
```\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 |
```\n/\*\*\n \* @notice function to bridge tokens after swap. This is used after swap function call\n \* @notice This method is payable because the caller is doing token transfer and briding operation\n \* @dev for usage, refer to controller implementations\n \* encodedData for bridge should follow the sequence of prop... | low |
```\n// The upper 16 bytes represent the pool id, so this would be pool id 1. See MixinStakinPool for more information.\nbytes32 constant internal INITIAL\_POOL\_ID = 0x0000000000000000000000000000000100000000000000000000000000000000;\n\n// The upper 16 bytes represent the pool id, so this would be an increment of 1. S... | low |
```\nif (!ASTARIA_ROUTER.isValidRefinance(lienData[lienId], ld)) {\n revert InvalidRefinance();\n}\n```\n | high |
```\n _addCategory(toCategory("protocol-owned-treasury"), true, 0xb600c5e2, 0x00000000); // getProtocolOwnedTreasuryOhm()`\n```\n | medium |
```\nfunction Verify(bytes memory proof, uint256[] memory public\_inputs)\n```\n | high |
```\nfunction verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n ... | none |
```\nfor (uint256 i = 0; i < committeeMembers\_.length; ++i) {\n address member = committeeMembers\_[i];\n committeeArray.push(member);\n committeeIndexPlusOne[member] = committeeArray.length;\n}\n```\n | medium |
```\nfunction sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, "Address: insufficient balance");\n\n (bool success, ) = recipient.call{value: amount}("");\n require(success, "Address: unable to send value, recipient may have reverted");\n}\n```\n | none |
```\n function storePrice(address asset_) public override permissioned {\n Asset storage asset = _assetData[asset_];\n\n // Check if asset is approved\n if (!asset.approved) revert PRICE_AssetNotApproved(asset_);\n\n // Get the current price for the asset\n (uint256 price, uint48 curren... | high |
```\nconstructor() {\n _setOwner(_msgSender());\n}\n```\n | none |
```\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 _setOwner(address newOwner) private {\n address oldOwner = _owner;\n _owner = newOwner;\n emit OwnershipTransferred(oldOwner, newOwner);\n}\n```\n | none |
```\nfunction setOperatorAddresses(\n uint256 \_operatorIndex,\n address \_operatorAddress,\n address \_feeRecipientAddress\n) external onlyActiveOperatorFeeRecipient(\_operatorIndex) {\n \_checkAddress(\_operatorAddress);\n \_checkAddress(\_feeRecipientAddress);\n StakingContractStorageLib.OperatorsSlot storage operat... | high |
```\nfunction enableSwapAndLiquify(bool enabled) public onlyOwner {\n require(swapAndLiquifyEnabled != enabled);\n swapAndLiquifyEnabled = enabled;\n emit EnableSwapAndLiquify(enabled);\n}\n```\n | none |
```\nfunction \_removeFromQueue(uint256 \_countToRemove) internal {\n for (uint256 i = 0; i < \_countToRemove; i++) {\n delete withdrawalsInfo[withdrawalQueue[i]];\n } \n\n if (\_countToRemove == withdrawalQueue.length) {\n delete withdrawalQueue;\n } else {\n uint256 \_remainingArrLength = withdrawalQue... | medium |
```\nfunction updateAndDistributeERC20(\n address split,\n ERC20 token,\n address[] calldata accounts,\n uint32[] calldata percentAllocations,\n uint32 distributorFee,\n address distributorAddress\n)\n external\n override\n onlySplitController(split)\n validSplit(accounts, percentAllocations, distributorFee)\... | none |
```\n/// @notice Returns the total balance (in asset tokens). This includes the deposits and interest.\n/// @return The underlying balance of asset tokens\nfunction balanceOfToken(address addr) public override returns (uint256) {\n if (balances[addr] == 0) return 0;\n ISushiBar bar = ISushiBar(sushiBar);\n\n u... | medium |
```\n/\*\*\n \* @dev Reports unauthorized signing for the provided group. Must provide\n \* a valid signature of the group address as a message. Successful signature\n \* verification means the private key has been leaked and all group members\n \* should be punished by seizing their tokens. The submitter of this proof... | high |
```\nfunction _withdrawDividendOfUser(address payable user) internal override returns (uint256)\n{\n uint256 _withdrawableDividend = withdrawableDividendOf(user);\n if (_withdrawableDividend > 0) {\n withdrawnDividends[user] = withdrawnDividends[user].add(_withdrawableDividend);\n\n address tokenAdd... | none |
```\n function isAdminOfHat(address _user, uint256 _hatId) public view returns (bool isAdmin) {\n uint256 linkedTreeAdmin;\n uint32 adminLocalHatLevel;\n if (isLocalTopHat(_hatId)) {\n linkedTreeAdmin = linkedTreeAdmins[getTopHatDomain(_hatId)];\n if (linkedTreeAdmin == 0) ... | medium |
```\n ICurvePool(pool).remove_liquidity_one_coin(\n amountPosRemove,\n int128(tokenIndex),\n 0\n );\n```\n | high |
```\nFile: StrategyUtils.sol\n function _executeTradeExactIn(\n TradeParams memory params,\n ITradingModule tradingModule,\n address sellToken,\n address buyToken,\n uint256 amount,\n bool useDynamicSlippage\n ) internal returns (uint256 amountSold, uint256 amountBought) ... | medium |
```\n/// @notice we poll the Keep contract to retrieve our pubkey\n/// @dev We store the pubkey as 2 bytestrings, X and Y.\n/// @param \_d deposit storage pointer\n/// @return True if successful, otherwise revert\nfunction retrieveSignerPubkey(DepositUtils.Deposit storage \_d) public {\n require(\_d.inAwaitingSigner... | high |
```\nfunction maxMint(address) public view virtual returns (uint256) {\n return type(uint256).max;\n}\n```\n | medium |
```\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 |
```\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 |
```\nconstructor() {\n _transferOwnership(_msgSender());\n}\n```\n | none |
```\nfunction _approve(address owner, address spender, uint256 amount) private {\n require(owner != address(0), "ERC20: approve from the zero address");\n require(spender != address(0), "ERC20: approve to the zero address");\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\... | none |
```\nuint256 totalCollateralAmount = bid.collateralAmount + collateralAmount;\n```\n | medium |
```\nFile: TreasuryAction.sol\n function _executeRebalance(uint16 currencyId) private {\n IPrimeCashHoldingsOracle oracle = PrimeCashExchangeRate.getPrimeCashHoldingsOracle(currencyId);\n uint8[] memory rebalancingTargets = _getRebalancingTargets(currencyId, oracle.holdings());\n (RebalancingDat... | medium |
```\nfunction toHexString(address addr) internal pure returns (string memory) {\n return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\n}\n```\n | none |
```\nfunction cancelControlTransfer(address split)\n external\n override\n onlySplitController(split)\n{\n delete splits[split].newPotentialController;\n emit CancelControlTransfer(split);\n}\n```\n | none |
```\nfor (uint i = 0; i < shares.length; ++i) {\n skaleToken.send(address(skaleBalances), shares[i].amount, abi.encode(shares[i].holder));\n\n uint created = delegationController.getDelegation(shares[i].delegationId).created;\n uint delegationStarted = timeHelpers.getNextMonthStartFromDate(created);\n skale... | high |
```\nfunction safeApprove(address \_token, address \_spender, uint256 \_value) public onlyOwner {\n\n (bool success, bytes memory returndata) = \_token.call(abi.encodeWithSignature("approve(address,uint256)", \_spender, \_value));\n\n require(success, "SafeERC20: low-level call failed");\n\n}\n```\n | high |
```\nfunction getAllDelegationRequests() external returns(uint[] memory) {\n revert("Not implemented");\n}\n\nfunction getDelegationRequestsForValidator(uint validatorId) external returns (uint[] memory) {\n revert("Not implemented");\n}\n```\n | medium |
```\nconstructor() ERC20("Pepe", "PEPE") {\n\n IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);\n\n excludeFromMaxTransaction(address(_uniswapV2Router), true);\n uniswapV2Router = _uniswapV2Router;\n\n uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.fa... | 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(bool success, bytes memory result) = addressAt(routeId).delegatecall(\n```\n | high |
```\nfunction functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, "Address: low-level delegate call failed");\n}\n```\n | none |
```\nfunction \_cacheFundraisingParams(\n address \_owner,\n string \_id,\n ERC20 \_collateralToken,\n MiniMeToken \_bondedToken,\n uint64 \_period,\n uint256 \_exchangeRate,\n uint64 \_openDate,\n uint256 \_reserveRatio,\n uint256 \_batc... | low |
```\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 |
```\nfunction ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n // (a + b - 1) / b can overflow on addition, so we distribute.\n return a / b + (a % b == 0 ? 0 : 1);\n}\n```\n | none |
```\nfunction getLotPriceByTotalBids(uint256 \_index) override public view returns (uint256) {\n uint256 calcBase = 1 ether;\n return calcBase.mul(getLotTotalBidAmount(\_index)).div(getLotTotalRPLAmount(\_index));\n}\n```\n | low |
```\nfunction _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {\n // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and\n // then delete the last slot (swap and pop).\n\n uint256 lastTokenIndex = _allTokens.length - 1;\n uint256 tokenIndex = ... | none |
```\nPlasmaFramework private plasmaFramework;\n```\n | low |
```\nPerpDepository.sol\n function rebalanceLite(\n uint256 amount,\n int8 polarity,\n uint160 sqrtPriceLimitX96,\n address account\n ) external nonReentrant returns (uint256, uint256) {\n if (polarity == -1) {\n return\n _rebalanceNegativePnlLite(amoun... | medium |
```\nfunction renounceOwnership() external onlyOwner {\n _transferOwnership(address(0));\n}\n```\n | none |
```\n function getBorrowRatePerBlock(address \_token) public view returns(uint) {\n if(!globalConfig.tokenInfoRegistry().isSupportedOnCompound(\_token))\n // If the token is NOT supported by the third party, borrowing rate = 3% + U \* 15%.\n return getCapitalUtilizationRatio(\_token).mul(glo... | medium |
```\nconstructor() {\n _transferOwnership(_msgSender());\n}\n```\n | none |
```\n receive() external payable {\n emit EthReceived(msg.sender, msg.value);\n\n```\n | none |
```\nfunction functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n}\n```\n | none |
```\nfunction \_cacheFundraisingApps(\n Agent \_reserve,\n Presale \_presale,\n MarketMaker \_marketMaker,\n Tap \_tap,\n Controller \_controller,\n TokenManager \_tokenManager\n)\n internal\n returns (FundraisingApps memory fundraisingApps)\n{\n fundraisin... | low |
```\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 public constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;\n\n// rest of code\n\n// Only need ability to check for read-only reentrancy for pools containing native Eth.\nif (checkReentrancy) {\n if (tokens[0] != ETH && tokens[1] != ETH) revert MustHaveEthForReentrancy();\n}\n```\n | high |
```\ndaiAToken balance = 30000\nwethDebtToken balance = 10\n\nThe price of WETH when the trade was opened was ~ 3000 DAI\n```\n | high |
```\n function baseOracleCircuitBreaker(\n uint256 protocolPrice,\n uint80 roundId,\n int256 chainlinkPrice,\n uint256 timeStamp,\n uint256 chainlinkPriceInEth\n ) private view returns (uint256 _protocolPrice) {\n \n // more code\n\n if (invalidFetchData || ... | low |
```\n function setTierWinner(\n string calldata _bountyId,\n uint256 _tier,\n string calldata _winner\n ) external {\n IBounty bounty = getBounty(_bountyId);\n require(msg.sender == bounty.issuer(), Errors.CALLER_NOT_ISSUER);\n bounty.setTierWinner(_winner, _tier);\n\n ... | medium |
```\nfunction getNumberOfTokenHolders() external view returns (uint256) {\n return tokenHoldersMap.keys.length;\n}\n```\n | none |
```\nfunction supplyTokenTo(uint256 \_amount, address to) override external {\n uint256 shares = \_tokenToShares(\_amount);\n\n \_mint(to, shares);\n\n // NOTE: we have to deposit after calculating shares to mint\n token.safeTransferFrom(msg.sender, address(this), \_amount);\n\n \_depositInVault();\n\n ... | high |
```\nfunction receiverwallets()\n external\n view\n returns (address _marketingWallet, address _projectWallet)\n{\n return (marketingWallet, projectWallet);\n}\n```\n | none |
```\n function _isExternalLendingUnhealthy(\n uint16 currencyId,\n IPrimeCashHoldingsOracle oracle,\n PrimeRate memory pr\n ) internal view returns (bool isExternalLendingUnhealthy, OracleData memory oracleData, uint256 targetAmount) {\n// rest of code\n\n PrimeCashFactors memory factors... | medium |
```\nfunction emergencyResume(\n GMXTypes.Store storage self\n ) external {\n GMXChecks.beforeEmergencyResumeChecks(self);\n\n self.status = GMXTypes.Status.Resume;\n\n self.refundee = payable(msg.sender);\n\n GMXTypes.AddLiquidityParams memory _alp;\n\n _alp.tokenAAmt = self.tokenA.balanceOf(address... | medium |
```\n function getPriceFromChainlink(address base, address quote) internal view returns (uint256) {\n (, int256 price,,,) = registry.latestRoundData(base, quote);\n require(price > 0, "invalid price");\n\n // Extend the decimals to 1e18.\n return uint256(price) * 10 ** (18 - uint256(regis... | medium |
```\nint256 premium = getMarkPriceTwap() - underlyingPrice;\n```\n | medium |
```\nfunction getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n}\n```\n | none |
```\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 |
```\nfunction allowance(address owner, address spender) public view override returns (uint256) {\n return _allowances[owner][spender];\n}\n```\n | none |
```\nfor (uint256 i = 0; i < epochNumbers.length; i++) {\n if (\_claimedRewardsPerEpoch[shareId][epochNumbers[i]][\_msgSender()]) revert AlreadyClaimed();\n \_claimedRewardsPerEpoch[shareId][epochNumbers[i]][\_msgSender()] = true;\n uint256 epochRewards = \_availableReward(shareId, isDelegator, epochNumbers[i]... | low |
```\n for (uint256 i = 0; i < rewardTokens.length; i++) {\n uint256 rewards = _doCutRewardsFee(rewardTokens[i]);\n _ensureApprove(rewardTokens[i], address(swapRouter), rewards);\n swapRouter.swapExactTokensForTokens(\n rewards,\n 0,\n swapPath[i],\n ad... | high |
```\n// Check header chain length\nif (\_headers.length % 80 != 0) {return ERR\_BAD\_LENGTH;}\n```\n | low |
```\nuint256 messageNumber = nextMessageNumber;\nuint256 valueSent = msg.value - \_fee;\n\nbytes32 messageHash = keccak256(abi.encode(msg.sender, \_to, \_fee, valueSent, messageNumber, \_calldata));\n```\n | high |
```\naveragePrice = existing._initAcc * 1e18 / INIT_SAMPLE_COUNT;\naveragePrice = 36e18 * 1e18 / 18\naveragePrice = 36e36 / 18\naveragePrice = 2e36\n```\n | high |
```\nfunction mint(uint256 shares, address receiver) public isOpen returns (uint256 assets) {\n if(shares == 0) revert InvalidParams();\n // These transfers need to happen before the mint, and this is forcing a higher degree of coupling than is ideal\n assets = previewMint(shares);\n asset.transferFrom(msg.sender, addr... | low |
```\nfunction execute(address to, bytes calldata data, uint256 value) external onlyOwner returns (bytes memory){\n require(to != address(0));\n-> (bool success, bytes memory returnData) = to.call{value: value}(data);\n if (!success) {\n assembly {\n let ptr := mload(0x40)\n ... | medium |
```\n function _executeAutomation( address _wallet, address _subAccount, address _strategy,\n Types.Executable[] memory _actionExecs ) internal {\n uint256 actionLen = _actionExecs.length;\n if (actionLen == 0) {\n revert InvalidActions();\n } else {\n uint256 idx = 0;\n do {... | medium |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.