function
stringlengths 12
63.3k
| severity
stringclasses 4
values |
|---|---|
```\nfunction div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n require(b > 0, errorMessage);\n uint256 c = a / b;\n return c;\n}\n```\n | none |
```\nsignedOnly(abi.encodePacked(msg.sender, instance, data), signature)\n```\n | medium |
```\nFile: LimitOrderRegistry.sol\n function claimOrder(uint128 batchId, address user) external payable returns (ERC20, uint256) {\n..SNIP..\n // Transfer fee in.\n address sender = _msgSender();\n if (msg.value >= userClaim.feePerUser) {\n // refund if necessary.\n uint256 refund = msg.value - userClaim.feePerUser;\n if (refund > 0) sender.safeTransferETH(refund);\n } else {\n WRAPPED_NATIVE.safeTransferFrom(sender, address(this), userClaim.feePerUser);\n // If value is non zero send it back to caller.\n if (msg.value > 0) sender.safeTransferETH(msg.value);\n }\n```\n | medium |
```\n/// @notice Verifies the nonce of a voter on a proposal\n/// @param \_proposalId The id of the proposal\n/// @param \_voter The address of the voter\n/// @param \_relayerNonce The nonce submitted by the relayer\nfunction verifyNonce(uint256 \_proposalId, address \_voter, uint256 \_relayerNonce) public view {\n Proposal storage \_proposal = proposals[\_proposalId];\n require(\_proposal.voters[\_voter].nonce < \_relayerNonce, "INVALID\_NONCE");\n}\n```\n | high |
```\nfunction _getStakeInfo(address addr) internal view returns (StakeInfo memory info) {\n DepositInfo storage depositInfo = deposits[addr];\n info.stake = depositInfo.stake;\n info.unstakeDelaySec = depositInfo.unstakeDelaySec;\n}\n```\n | none |
```\nFile: BalancerEnvironment.py\n "postMaturitySettlementSlippageLimitPercent": 10e6, # 10%\n "emergencySettlementSlippageLimitPercent": 10e6, # 10%\n```\n | medium |
```\nFile: LimitOrderRegistry.sol\n function setFastGasFeed(address feed) external onlyOwner {\n fastGasFeed = feed;\n }\n```\n | high |
```\n function verifyPrices(PriceSig memory priceSig, address partyA) internal view {\n MuonStorage.Layout storage muonLayout = MuonStorage.layout();\n require(priceSig.prices.length == priceSig.symbolIds.length, "LibMuon: Invalid length");\n bytes32 hash = keccak256(\n abi.encodePacked(\n muonLayout.muonAppId,\n priceSig.reqId,\n address(this),\n partyA,\n priceSig.upnl,\n priceSig.totalUnrealizedLoss,\n priceSig.symbolIds,\n priceSig.prices,\n priceSig.timestamp,\n getChainId()\n )\n );\n verifyTSSAndGateway(hash, priceSig.sigs, priceSig.gatewaySignature);\n }\n```\n | high |
```\nfunction \_buyPolicyFor(\n address \_policyHolderAddr,\n uint256 \_epochsNumber,\n uint256 \_coverTokens\n) internal {\n```\n | low |
```\n// Prevent `executeTransaction` from being called when context is already set\naddress currentContextAddress\_ = currentContextAddress;\nif (currentContextAddress\_ != address(0)) {\n LibRichErrors.rrevert(LibExchangeRichErrors.TransactionInvalidContextError(\n transactionHash,\n currentContextAddress\_\n ));\n}\n```\n | medium |
```\n function repay(uint256 repayAmount, uint256 _userLoanId) external {\n Loan memory userLoan = loans[msg.sender][_userLoanId];\n if(userLoan.borrowedAmount < repayAmount) revert ExcessiveRepay();\n if(block.timestamp > userLoan.endDate) revert LoanExpired();\n uint256 interestLoanRatio = FixedPointMathLib.divWad(userLoan.interest, userLoan.borrowedAmount);\nL425 uint256 interest = FixedPointMathLib.mulWadUp(repayAmount, interestLoanRatio); //@audit rounding issue\n outstandingDebt -= repayAmount - interest > outstandingDebt ? outstandingDebt : repayAmount - interest;\n // rest of code\n }\n// rest of code\n function liquidate(address user, uint256 _userLoanId) external {\n Loan memory userLoan = loans[msg.sender][_userLoanId];\n if(block.timestamp < userLoan.endDate || userLoan.liquidated || userLoan.borrowedAmount == 0) revert Unliquidatable();\n loans[user][_userLoanId].liquidated = true;\n loans[user][_userLoanId].borrowedAmount = 0;\nL448 outstandingDebt -= userLoan.borrowedAmount - userLoan.interest;\n // rest of code\n }\n```\n | medium |
```\n IUniswapV3Pool(underlyingTrustedPools[500].poolAddress)\n```\n | high |
```\nfunction userWithdraw(address to, address user, address token, uint256 dTokenAmount) external nonReentrant allowedToken(token) returns(uint256 amount) {\n accrueInterest(token);\n AssetInfo storage info = assetInfo[token];\n require(dTokenAmount <= IDToken(info.dToken).balanceOf(msg.sender), Errors.DTOKEN_BALANCE_NOT_ENOUGH);\n\n amount = dTokenAmount.mul(_getExchangeRate(token));//@audit does not check amount value\n IDToken(info.dToken).burn(msg.sender, dTokenAmount);\n IERC20(token).safeTransfer(to, amount);\n info.balance = info.balance - amount;\n\n // used for calculate user withdraw amount\n // this function could be called from d3Proxy, so we need "user" param\n // In the meantime, some users may hope to use this function directly,\n // to prevent these users fill "user" param with wrong addresses,\n // we use "msg.sender" param to check.\n emit UserWithdraw(msg.sender, user, token, amount);\n }\n```\n | medium |
```\nconstructor(string memory name_, string memory symbol_) {\n _name = name_;\n _symbol = symbol_;\n}\n```\n | none |
```\nuint256 bAsset\_decimals = CommonHelpers.getDecimals(\_bAsset);\n```\n | low |
```\nfallback () external [payable];\nfallback (bytes calldata _input) external [payable] returns (bytes memory _output);\n```\n | 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)\n{\n _updateSplit(split, accounts, percentAllocations, distributorFee);\n // know splitHash is valid immediately after updating; only accessible via controller\n _distributeERC20(\n split,\n token,\n accounts,\n percentAllocations,\n distributorFee,\n distributorAddress\n );\n}\n```\n | none |
```\nfunction getETHBalance(address account) external view returns (uint256) {\n return\n ethBalances[account] + (splits[account].hash != 0 ? account.balance : 0);\n}\n```\n | none |
```\nfunction supportsInterface (bytes4 interfaceID) public returns (bool) {\n return interfaceID == ERC20ID || interfaceID == ERC165ID;\n}\n```\n | low |
```\n_manage(context, depositAssets, claimAmount, !depositAssets.isZero() || !redeemShares.isZero());\n```\n | medium |
```\nfunction average(uint256 a, uint256 b) internal pure returns (uint256) {\n // (a + b) / 2 can overflow.\n return (a & b) + (a ^ b) / 2;\n}\n```\n | none |
```\nfunction setGasPriceLimit(uint256 GWEI) external onlyOwner {\n require(GWEI >= 50, "can never be set lower than 50");\n gasPriceLimit = GWEI * 1 gwei;\n}\n```\n | none |
```\nfunction delBot(address notbot) public onlyOwner {\n bots[notbot] = false;\n}\n```\n | none |
```\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 |
```\nconstructor () {\n address msgSender = _msgSender();\n _owner = msgSender;\n emit OwnershipTransferred(address(0), msgSender);\n}\n```\n | none |
```\nfunction _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {\n // To prevent a gap in from's 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 = ERC721.balanceOf(from) - 1;\n uint256 tokenIndex = _ownedTokensIndex[tokenId];\n\n // When the token to delete is the last token, the swap operation is unnecessary\n if (tokenIndex != lastTokenIndex) {\n uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];\n\n _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token\n _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index\n }\n\n // This also deletes the contents at the last position of the array\n delete _ownedTokensIndex[tokenId];\n delete _ownedTokens[from][lastTokenIndex];\n}\n```\n | none |
```\n/* snip */\n// now check rate limits\nbool isAmountRateLimited = _isOutboundAmountRateLimited(internalAmount);\nif (!shouldQueue && isAmountRateLimited) {\n revert NotEnoughCapacity(getCurrentOutboundCapacity(), amount);\n}\nif (shouldQueue && isAmountRateLimited) {\n // emit an event to notify the user that the transfer is rate limited\n emit OutboundTransferRateLimited(\n msg.sender, sequence, amount, getCurrentOutboundCapacity()\n );\n\n // queue up and return\n _enqueueOutboundTransfer(\n sequence,\n trimmedAmount,\n recipientChain,\n recipient,\n msg.sender,\n transceiverInstructions\n );\n\n // refund price quote back to sender\n _refundToSender(msg.value);\n\n // return the sequence in the queue\n return sequence;\n}\n/* snip */\n```\n | high |
```\nfunction transferFrom(\n address sender,\n address recipient,\n uint amount\n) external override returns (bool) {\n if (allowance[sender][msg.sender] != type(uint).max) {\n require(allowance[sender][msg.sender] >= amount, "VoxNET: insufficient allowance");\n allowance[sender][msg.sender] = allowance[sender][msg.sender] - amount;\n }\n\n return doTransfer(sender, recipient, amount);\n}\n```\n | none |
```\nfunction \_initialize(\n string memory \_name,\n string memory \_symbol,\n uint8 \_decimals,\n IControllerInterface \_controller,\n IInterestRateModelInterface \_interestRateModel\n) internal virtual {\n controller = \_controller;\n interestRateModel = \_interestRateModel;\n accrualBlockNumber = block.number;\n borrowIndex = BASE;\n flashloanFeeRatio = 0.0008e18;\n protocolFeeRatio = 0.25e18;\n \_\_Ownable\_init();\n \_\_ERC20\_init(\_name, \_symbol, \_decimals);\n \_\_ReentrancyGuard\_init();\n\n uint256 chainId;\n\n assembly {\n chainId := chainid()\n }\n DOMAIN\_SEPARATOR = keccak256(\n abi.encode(\n keccak256(\n "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"\n ),\n keccak256(bytes(\_name)),\n keccak256(bytes("1")),\n chainId,\n address(this)\n )\n );\n}\n```\n | low |
```\nerror Forbidden();\nerror InvalidFee();\nerror Deactivated();\nerror NoOperators();\nerror InvalidCall();\nerror Unauthorized();\nerror DepositFailure();\nerror DepositsStopped();\nerror InvalidArgument();\nerror UnsortedIndexes();\nerror InvalidPublicKeys();\nerror InvalidSignatures();\nerror InvalidWithdrawer();\nerror InvalidZeroAddress();\nerror AlreadyInitialized();\nerror InvalidDepositValue();\nerror NotEnoughValidators();\nerror InvalidValidatorCount();\nerror DuplicateValidatorKey(bytes);\nerror FundedValidatorDeletionAttempt();\nerror OperatorLimitTooHigh(uint256 limit, uint256 keyCount);\nerror MaximumOperatorCountAlreadyReached();\nerror LastEditAfterSnapshot();\nerror PublicKeyNotInContract();\n```\n | low |
```\nfunction getCumulativeTokenPrice() internal view returns (uint) {\n uint cumulativePrice;\n\n if (IUniswapV2Pair(pair).token0() == address(this)) {\n cumulativePrice = IUniswapV2Pair(pair).price0CumulativeLast();\n } else {\n cumulativePrice = IUniswapV2Pair(pair).price1CumulativeLast();\n }\n\n if (cumulativePrice != 0) {\n uint32 blockTimestamp = uint32(block.timestamp % 2**32);\n\n (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();\n\n if (blockTimestampLast != blockTimestamp) {\n uint32 timeElapsed = blockTimestamp - blockTimestampLast;\n\n if (IUniswapV2Pair(pair).token0() == address(this)) {\n cumulativePrice += FixedPoint.fraction(reserve1, reserve0) * timeElapsed;\n } else {\n cumulativePrice += FixedPoint.fraction(reserve0, reserve1) * timeElapsed;\n }\n }\n }\n\n return cumulativePrice;\n}\n```\n | none |
```\nFile: contracts\OperatorTokenomics\SponsorshipPolicies\VoteKickPolicy.sol\n function onFlag(address target, address flagger) external {\n require(flagger != target, "error_cannotFlagSelf");\n require(voteStartTimestamp[target] == 0 && block.timestamp > protectionEndTimestamp[target], "error_cannotFlagAgain"); // solhint-disable-line not-rely-on-time\n require(stakedWei[flagger] >= minimumStakeOf(flagger), "error_notEnoughStake");\n require(stakedWei[target] > 0, "error_flagTargetNotStaked"); //@audit possible front run\n```\n | medium |
```\n function create(\n FixedStrikeOptionToken optionToken_,\n uint256 amount_\n ) external override nonReentrant {\n // rest of code\n if (call) {\n // rest of code\n } else {\n uint256 quoteAmount = amount_.mulDiv(strikePrice, 10 ** payoutToken.decimals());\n // rest of code\n quoteToken.safeTransferFrom(msg.sender, address(this), quoteAmount);\n // rest of code\n }\n\n optionToken.mint(msg.sender, amount_);\n }\n```\n | high |
```\nerror Forbidden();\nerror InvalidFee();\nerror Deactivated();\nerror NoOperators();\nerror InvalidCall();\nerror Unauthorized();\nerror DepositFailure();\nerror DepositsStopped();\nerror InvalidArgument();\nerror UnsortedIndexes();\nerror InvalidPublicKeys();\nerror InvalidSignatures();\nerror InvalidWithdrawer();\nerror InvalidZeroAddress();\nerror AlreadyInitialized();\nerror InvalidDepositValue();\nerror NotEnoughValidators();\nerror InvalidValidatorCount();\nerror DuplicateValidatorKey(bytes);\nerror FundedValidatorDeletionAttempt();\nerror OperatorLimitTooHigh(uint256 limit, uint256 keyCount);\nerror MaximumOperatorCountAlreadyReached();\nerror LastEditAfterSnapshot();\nerror PublicKeyNotInContract();\n```\n | low |
```\nfunction log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = log256(value);\n return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\n }\n}\n```\n | none |
```\n // Now pull in the tokens (Should have permission)\n // We only want to pull the tokens with accounting\n profitToken.transferFrom(strategy, address(this), _amount);\n emit ProfitReceivedFromStrategy(_amount);\n```\n | medium |
```\n/// @notice Ensures that the caller is the admin\nmodifier onlyActiveOperator(uint256 \_operatorIndex) {\n \_onlyActiveOperator(\_operatorIndex);\n \_;\n}\n```\n | low |
```\n function changeTreasury(uint256 _marketId, address _treasury)\n public\n onlyTimeLocker\n {\n if (_treasury == address(0)) revert AddressZero();\n\n address[2] memory vaults = marketIdToVaults[_marketId];\n\n if (vaults[0] == address(0) || vaults[1] == address(0)) {\n revert MarketDoesNotExist(_marketId);\n }\n IVaultV2(vaults[0]).whiteListAddress(_treasury);\n IVaultV2(vaults[1]).whiteListAddress(_treasury);\n IVaultV2(vaults[0]).setTreasury(treasury);\n IVaultV2(vaults[1]).setTreasury(treasury);\n\n emit AddressWhitelisted(_treasury, _marketId);\n }\n```\n | medium |
```\nfunction isBlacklisted(address account) public view returns(bool) {\n return _isBlackListedBot[account];\n}\n```\n | none |
```\nAttackerContract.flashLoan() ->\n // Borrow lots of tokens and trigger a callback.\n SomeProtocol.flashLoan() ->\n AttackerContract.exploit()\n\nAttackerContract.exploit() ->\n // Join a Balancer Pool using the borrowed tokens and send some ETH along with the call.\n BalancerVault.joinPool() ->\n // The Vault will return the excess ETH to the sender, which will reenter this contract.\n // At this point in the execution, the BPT supply has been updated but the token balances have not.\n AttackerContract.receive()\n\nAttackerContract.receive() ->\n // Liquidate a position using the same Balancer Pool as collateral.\n BlueBerryBank.liquidate() ->\n // Call to the oracle to check the price.\n BalancerPairOracle.getPrice() ->\n // Query the token balances. At this point in the execution, these have not been updated (see above).\n // So, the balances are still the same as before the start of the large pool join.\n BalancerVaul.getPoolTokens()\n\n // Query the BPT supply. At this point in the execution, the supply has already been updated (see above).\n // So, it includes the latest large pool join, and as such the BPT supply has grown by a large amount.\n BalancerPool.getTotalSupply()\n\n // Now the price is computed using both balances and supply, and the result is much smaller than it should be.\n price = f(balances) / pool.totalSupply()\n\n // The position is liquidated under false pretenses.\n```\n | high |
```\nfunction _approve(\n address owner,\n address spender,\n uint256 amount\n) 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);\n}\n```\n | none |
```\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 properties in Stargate-BridgeData struct\n \* @param swapId routeId for the swapImpl\n \* @param swapData encoded data for swap\n \* @param stargateBridgeData encoded data for StargateBridgeData\n \*/\nfunction swapAndBridge(\n```\n | low |
```\n function getPoolPrice() public view returns (uint256 price, uint256 \n inversed){\n (uint160 sqrtPriceX96, , , , , , ) = pool.slot0();\n uint256 p = uint256(sqrtPriceX96) * uint256(sqrtPriceX96) * (10 \n ** token0.decimals());\n // token0/token1 in 1e18 format\n price = p / (2 ** 192);\n inversed = 1e36 / price;\n }\n```\n | medium |
```\n(bool sentToUser, ) = recipient.call{ value: finalUserAmount }("");\nrequire(sentToUser, "Failed to send Ether");\n```\n | low |
```\nfunction closeMakeFor(\n address account,\n UFixed18 amount\n )\n public\n nonReentrant\n notPaused\n onlyAccountOrMultiInvoker(account)\n settleForAccount(account)\n takerInvariant\n closeInvariant(account)\n liquidationInvariant(account)\n {\n _closeMake(account, amount);\n }\n```\n | medium |
```\nfunction _validateAndUpdateNonce(address sender, uint256 nonce) internal returns (bool) {\n\n uint192 key = uint192(nonce >> 64);\n uint64 seq = uint64(nonce);\n return nonceSequenceNumber[sender][key]++ == seq;\n}\n```\n | none |
```\nfunction linkNodeAddress(address validatorAddress, address nodeAddress) external allow("DelegationService") {\n uint validatorId = getValidatorId(validatorAddress);\n require(\_validatorAddressToId[nodeAddress] == 0, "Validator cannot override node address");\n \_validatorAddressToId[nodeAddress] = validatorId;\n}\n\nfunction unlinkNodeAddress(address validatorAddress, address nodeAddress) external allow("DelegationService") {\n uint validatorId = getValidatorId(validatorAddress);\n require(\_validatorAddressToId[nodeAddress] == validatorId, "Validator hasn't permissions to unlink node");\n \_validatorAddressToId[nodeAddress] = 0;\n}\n```\n | high |
```\n function setFlagger(\n STypes.ShortRecord storage short,\n address cusd,\n uint16 flaggerHint\n ) internal {\n\n if (flagStorage.g_flaggerId == 0) {\n address flaggerToReplace = s.flagMapping[flaggerHint];\n\n // @audit if timeDiff > firstLiquidationTime, replace the flagger address\n\n uint256 timeDiff = flaggerToReplace != address(0)\n ? LibOrders.getOffsetTimeHours()\n - s.assetUser[cusd][flaggerToReplace].g_updatedAt\n : 0;\n //@dev re-use an inactive flaggerId\n if (timeDiff > LibAsset.firstLiquidationTime(cusd)) {\n delete s.assetUser[cusd][flaggerToReplace].g_flaggerId;\n short.flaggerId = flagStorage.g_flaggerId = flaggerHint;\n\n // more code\n\n s.flagMapping[short.flaggerId] = msg.sender;\n```\n | high |
```\nfunction registerDomain(\n uint256 parentId,\n string memory name,\n address domainOwner,\n address minter\n) external override onlyController returns (uint256) {\n // Create the child domain under the parent domain\n uint256 labelHash = uint256(keccak256(bytes(name)));\n address controller = msg.sender;\n\n // Domain parents must exist\n require(\_exists(parentId), "Zer0 Registrar: No parent");\n\n // Calculate the new domain's id and create it\n uint256 domainId =\n uint256(keccak256(abi.encodePacked(parentId, labelHash)));\n \_createDomain(domainId, domainOwner, minter, controller);\n\n emit DomainCreated(domainId, name, labelHash, parentId, minter, controller);\n\n return domainId;\n```\n | high |
```\ncontracts/user/UserManager.sol\n\n function unstake(uint96 amount) external whenNotPaused nonReentrant {\n Staker storage staker = stakers[msg.sender];\n // Stakers can only unstaked stake balance that is unlocked. Stake balance\n // becomes locked when it is used to underwrite a borrow.\n if (staker.stakedAmount - staker.locked < amount) revert InsufficientBalance();\n comptroller.withdrawRewards(msg.sender, stakingToken);\n uint256 remaining = IAssetManager(assetManager).withdraw(stakingToken, msg.sender, amount);\n if (uint96(remaining) > amount) {\n revert AssetManagerWithdrawFailed();\n }\n uint96 actualAmount = amount - uint96(remaining);\n _updateStakedCoinAge(msg.sender, staker);\n staker.stakedAmount -= actualAmount;\n totalStaked -= actualAmount;\n emit LogUnstake(msg.sender, actualAmount);\n }\n```\n | medium |
```\nconstructor(string memory name_, string memory symbol_) {\n _name = name_;\n _symbol = symbol_;\n}\n```\n | none |
```\n // ============================================\n // EMERGENCY WITHDRAWAL FUNCTIONS\n // Needs to be removed when final version deployed\n // ============================================\n function emergencyWithdraw(GlobalConfig globalConfig, address \_token) public {\n address cToken = globalConfig.tokenInfoRegistry().getCToken(\_token);\n// rest of code\n```\n | medium |
```\n function stake(\n uint256 amount_,\n bytes calldata proof_\n ) external nonReentrant requireInitialized updateRewards tryNewEpoch {\n// rest of code\n uint256 userBalance = stakeBalance[msg.sender];\n if (userBalance > 0) {\n // Claim outstanding rewards, this will update the rewards per token claimed\n _claimRewards();\n } else {\n // Initialize the rewards per token claimed for the user to the stored rewards per token\n rewardsPerTokenClaimed[msg.sender] = rewardsPerTokenStored;\n }\n\n // Increase the user's stake balance and the total balance\n stakeBalance[msg.sender] = userBalance + amount_;\n totalBalance += amount_;\n\n // Transfer the staked tokens from the user to this contract\n stakedToken.safeTransferFrom(msg.sender, address(this), amount_);\n }\n```\n | medium |
```\n// rest of code\n _credit(liquidators[account][newOrderId], accumulationResult.liquidationFee);\n _credit(referrers[account][newOrderId], accumulationResult.subtractiveFee);\n// rest of code\nfunction _credit(address account, UFixed6 amount) private {\n if (amount.isZero()) return;\n\n Local memory newLocal = _locals[account].read();\n newLocal.credit(amount);\n _locals[account].store(newLocal);\n}\n```\n | medium |
```\n sets contract.exists.0xfefe=true\n sets contract.name.0xfefe=test\n sets contract.address.test=0xfefe\n sets contract.abi.test=abi\n```\n | high |
```\nIf using contracts such as the ExchangeRouter, Oracle or Reader do note that their addresses will change as new logic is added\n```\n | medium |
```\nfunction toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {\n if (ShortString.unwrap(value) != _FALLBACK_SENTINEL) {\n return toString(value);\n } else {\n return store;\n }\n}\n```\n | none |
```\nfunction setUnlockSigner(address _unlockSigner ) external onlyRole(BRIDGE_MANAGER) {\n unlockSigner = _unlockSigner;\n}\n```\n | none |
```\nFile: ConvexStakingMixin.sol\n function _isInvalidRewardToken(address token) internal override view returns (bool) {\n return (\n token == TOKEN_1 ||\n token == TOKEN_2 ||\n token == address(CURVE_POOL_TOKEN) ||\n token == address(CONVEX_REWARD_POOL) ||\n token == address(CONVEX_BOOSTER) ||\n token == Deployments.ALT_ETH_ADDRESS\n );\n }\n```\n | medium |
```\nFile: src\Tranche.sol\n function redeemWithYT(address from, address to, uint256 pyAmount) external nonReentrant returns (uint256) {\n// rest of code\n accruedInTarget += _computeAccruedInterestInTarget(\n _gscales.maxscale,\n _lscale,\n// rest of code\n _yt.balanceOf(from)\n );\n..\n uint256 sharesRedeemed = pyAmount.divWadDown(_gscales.maxscale);\n// rest of code\n _target.safeTransfer(address(adapter), sharesRedeemed + accruedInTarget);\n (uint256 amountWithdrawn, ) = adapter.prefundedRedeem(to);\n// rest of code\n return amountWithdrawn;\n }\n```\n | high |
```\n // 9 >= 10 is false\n if (currentSignerCount >= maxSigs) {\n revert MaxSignersReached();\n }\n\n // msg.sender is a new signer so he is not yet owner\n if (safe.isOwner(msg.sender)) {\n revert SignerAlreadyClaimed(msg.sender);\n }\n\n // msg.sender is a valid signer, he wears the signer hat\n if (!isValidSigner(msg.sender)) {\n revert NotSignerHatWearer(msg.sender);\n }\n```\n | high |
```\n\_poolById[poolId].numberOfMakers = uint256(pool.numberOfMakers).safeAdd(1).downcastToUint32();\n```\n | high |
```\n/\*\*\n \* @notice allows improsening an Operator if the validator have not been exited until expectedExit\n \* @dev anyone can call this function\n \* @dev if operator has given enough allowence, they can rotate the validators to avoid being prisoned\n \*/\nfunction blameOperator(\n StakePool storage self,\n DataStoreUtils.DataStore storage DATASTORE,\n bytes calldata pk\n) external {\n if (\n block.timestamp > self.TELESCOPE.\_validators[pk].expectedExit &&\n self.TELESCOPE.\_validators[pk].state != 3\n ) {\n OracleUtils.imprison(\n DATASTORE,\n self.TELESCOPE.\_validators[pk].operatorId\n );\n }\n}\n```\n | medium |
```\ndebt_amount: uint256 = self._debt(_position_uid)\n margin_debt_ratio: uint256 = position.margin_amount * PRECISION / debt_amount\n\n\n amount_out_received: uint256 = self._swap(\n position.position_token, position.debt_token, _reduce_by_amount, min_amount_out\n )\n\n\n # reduce margin and debt, keep leverage as before\n reduce_margin_by_amount: uint256 = (\n amount_out_received * margin_debt_ratio / PRECISION\n )\n reduce_debt_by_amount: uint256 = amount_out_received - reduce_margin_by_amount\n\n\n position.margin_amount -= reduce_margin_by_amount\n\n\n burnt_debt_shares: uint256 = self._repay(position.debt_token, reduce_debt_by_amount)\n position.debt_shares -= burnt_debt_shares\n position.position_amount -= _reduce_by_amount\n```\n | high |
```\nif (validSignerCount <= target && validSignerCount != currentThreshold) {\n newThreshold = validSignerCount;\n} else if (validSignerCount > target && currentThreshold < target) {\n newThreshold = target;\n}\n```\n | high |
```\nfunction tryMul(\n uint256 a,\n uint256 b\n) internal pure returns (bool, uint256) {\n unchecked {\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n // benefit is lost if 'b' is also tested.\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n if (a == 0) return (true, 0);\n uint256 c = a * b;\n if (c / a != b) return (false, 0);\n return (true, c);\n }\n}\n```\n | none |
```\n if (self.withdrawCache.withdrawParams.token == address(self.WNT)) {\n self.WNT.withdraw(self.withdrawCache.tokensToUser);\naudit transfer ETH and call (bool success, ) = self.withdrawCache.user.call{value: address(this).balance}("");\n require(success, "Transfer failed.");\n } else {\n // Transfer requested withdraw asset to user\n IERC20(self.withdrawCache.withdrawParams.token).safeTransfer(\n self.withdrawCache.user,\n self.withdrawCache.tokensToUser\n );\n }\n\n // Transfer any remaining tokenA/B that was unused (due to slippage) to user as well\n self.tokenA.safeTransfer(self.withdrawCache.user, self.tokenA.balanceOf(address(this)));\n self.tokenB.safeTransfer(self.withdrawCache.user, self.tokenB.balanceOf(address(this)));\n\n // Burn user shares\n burn is after self.vault.burn(self.withdrawCache.user, self.withdrawCache.withdrawParams.shareAmt);\n```\n | medium |
```\n uint _claimable = claimable[_gauge];\n if (SATIN_CASH_LP_GAUGE == _gauge) {\n veShare = calculateSatinCashLPVeShare(_claimable);\n _claimable -= veShare;\n }\n if (_claimable > IMultiRewardsPool(_gauge).left(token) && _claimable / DURATION > 0) {\n claimable[_gauge] = 0;\n if (is4poolGauge[_gauge]) {\n IGauge(_gauge).notifyRewardAmount(token, _claimable, true);\n } else {\n IGauge(_gauge).notifyRewardAmount(token, _claimable, false);\n }\n emit DistributeReward(msg.sender, _gauge, _claimable);\n }\n```\n | high |
```\nfunction borrow(address account, address token, uint amt)\n external\n whenNotPaused\n onlyOwner(account)\n{\n if (registry.LTokenFor(token) == address(0))\n revert Errors.LTokenUnavailable();\n if (!riskEngine.isBorrowAllowed(account, token, amt))\n revert Errors.RiskThresholdBreached();\n if (IAccount(account).hasAsset(token) == false)\n IAccount(account).addAsset(token);\n if (ILToken(registry.LTokenFor(token)).lendTo(account, amt))\n IAccount(account).addBorrow(token);\n emit Borrow(account, msg.sender, token, amt);\n}\n```\n | medium |
```\nfunction _takeLiquidity(uint256 tLiquidity) private {\n uint256 currentRate = _getRate();\n uint256 rLiquidity = tLiquidity * currentRate;\n _rOwned[address(this)] = _rOwned[address(this)] + rLiquidity;\n if(_isExcluded[address(this)])\n _tOwned[address(this)] = _tOwned[address(this)] + tLiquidity;\n}\n```\n | none |
```\nfunction addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {\n // approve token transfer to cover all possible scenarios\n _approve(address(this), address(uniswapV2Router), tokenAmount);\n\n // add the liquidity\n uniswapV2Router.addLiquidityETH{value: ethAmount}(\n address(this),\n tokenAmount,\n 0, // slippage is unavoidable\n 0, // slippage is unavoidable\n address(0),\n block.timestamp\n );\n}\n```\n | none |
```\n/\*\* @dev All details needed to Forge with multiple bAssets \*/\nstruct ForgePropsMulti {\n bool isValid; // Flag to signify that forge bAssets have passed validity check\n Basset[] bAssets;\n address[] integrators;\n uint8[] indexes;\n}\n```\n | low |
```\nfunction _transferOwnership(address newOwner) internal {\n _owner = newOwner;\n emit OwnershipTransferred(newOwner);\n}\n```\n | none |
```\n/// @notice returns the Protocol-Controlled Value, User-circulating FEI, and\n/// Protocol Equity.\n/// @return protocolControlledValue : the total USD value of all assets held\n/// by the protocol.\n/// @return userCirculatingFei : the number of FEI not owned by the protocol.\n/// @return protocolEquity : the difference between PCV and user circulating FEI.\n/// If there are more circulating FEI than $ in the PCV, equity is 0.\n/// @return validityStatus : the current oracle validity status (false if any\n/// of the oracles for tokens held in the PCV are invalid, or if\n/// this contract is paused).\nfunction pcvStats() public override view returns (\n uint256 protocolControlledValue,\n uint256 userCirculatingFei,\n int256 protocolEquity,\n bool validityStatus\n) {\n uint256 \_protocolControlledFei = 0;\n validityStatus = !paused();\n\n // For each token// rest of code\n for (uint256 i = 0; i < tokensInPcv.length(); i++) {\n address \_token = tokensInPcv.at(i);\n uint256 \_totalTokenBalance = 0;\n\n // For each deposit// rest of code\n for (uint256 j = 0; j < tokenToDeposits[\_token].length(); j++) {\n address \_deposit = tokenToDeposits[\_token].at(j);\n\n // ignore deposits that are excluded by the Guardian\n if (!excludedDeposits[\_deposit]) {\n // read the deposit, and increment token balance/protocol fei\n (uint256 \_depositBalance, uint256 \_depositFei) = IPCVDepositBalances(\_deposit).resistantBalanceAndFei();\n \_totalTokenBalance += \_depositBalance;\n \_protocolControlledFei += \_depositFei;\n }\n }\n\n // If the protocol holds non-zero balance of tokens, fetch the oracle price to\n // increment PCV by \_totalTokenBalance \* oracle price USD.\n if (\_totalTokenBalance != 0) {\n (Decimal.D256 memory \_oraclePrice, bool \_oracleValid) = IOracle(tokenToOracle[\_token]).read();\n if (!\_oracleValid) {\n validityStatus = false;\n }\n protocolControlledValue += \_oraclePrice.mul(\_totalTokenBalance).asUint256();\n }\n }\n\n userCirculatingFei = fei().totalSupply() - \_protocolControlledFei;\n protocolEquity = int256(protocolControlledValue) - int256(userCirculatingFei);\n}\n```\n | high |
```\nfunction setMinFee(address token, uint256 _minFee) public onlyOwner {\n minFee[token] = _minFee;\n}\n```\n | none |
```\nFile: ProportionalRebalancingStrategy.sol\n function calculateRebalance(\n IPrimeCashHoldingsOracle oracle,\n uint8[] calldata rebalancingTargets\n ) external view override onlyNotional returns (RebalancingData memory rebalancingData) {\n address[] memory holdings = oracle.holdings();\n..SNIP..\n for (uint256 i; i < holdings.length;) {\n address holding = holdings[i];\n uint256 targetAmount = totalValue * rebalancingTargets[i] / uint256(Constants.PERCENTAGE_DECIMALS);\n uint256 currentAmount = values[i];\n\n redeemHoldings[i] = holding;\n depositHoldings[i] = holding;\n..SNIP..\n }\n\n rebalancingData.redeemData = oracle.getRedemptionCalldataForRebalancing(redeemHoldings, redeemAmounts);\n rebalancingData.depositData = oracle.getDepositCalldataForRebalancing(depositHoldings, depositAmounts);\n }\n```\n | medium |
```\nfunction withdrawTokens(address to, uint256 amount) external onlyController {\n TransferHelper.withdrawTokens(token, to, amount);\n if (IERC20(token).balanceOf(address(this)) == 0) selfdestruct;\n}\n```\n | low |
```\n// can we reproduce the same hash from the raw claim metadata?\nrequire(hashMatch(user\_id, user\_address, user\_amount, delegate\_address, leaf, eth\_signed\_message\_hash\_hex), 'TokenDistributor: Hash Mismatch.');\n```\n | low |
```\nfunction _transferBothExcluded(\n address sender,\n address recipient,\n uint256 tAmount\n) private {\n (\n uint256 tTransferAmount,\n uint256 tFee,\n uint256 tLiquidity,\n uint256 tWallet,\n uint256 tDonation\n ) = _getTValues(tAmount);\n (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(\n tAmount,\n tFee,\n tLiquidity,\n tWallet,\n tDonation,\n _getRate()\n );\n\n _tOwned[sender] = _tOwned[sender].sub(tAmount);\n _rOwned[sender] = _rOwned[sender].sub(rAmount);\n _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);\n _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);\n _takeLiquidity(tLiquidity);\n _takeWalletFee(tWallet);\n _takeDonationFee(tDonation);\n _reflectFee(rFee, tFee);\n emit Transfer(sender, recipient, tTransferAmount);\n}\n```\n | none |
```\n(, int256 price, , , ) = priceFeedDAIETH.latestRoundData();\n\nreturn\n (wethPriceUSD * 1e18) /\n ((DAIWethPrice + uint256(price) * 1e10) / 2);\n```\n | medium |
```\nuint256 shares = \_deposit(to, tokenAmount);\n\n// Transfer Token Transfer Message Sender\nIERC20Upgradeable(token).transferFrom(\n msg.sender,\n address(this),\n tokenAmount\n);\n```\n | high |
```\nfunction beforeRebalanceChecks(\n GMXTypes.Store storage self,\n GMXTypes.RebalanceType rebalanceType\n) external view {\n if (\n self.status != GMXTypes.Status.Open &&\n self.status != GMXTypes.Status.Rebalance_Open\n ) revert Errors.NotAllowedInCurrentVaultStatus();\n\n // Check that rebalance type is Delta or Debt\n // And then check that rebalance conditions are met\n // Note that Delta rebalancing requires vault's delta strategy to be Neutral as well\n if (rebalanceType == GMXTypes.RebalanceType.Delta && self.delta == GMXTypes.Delta.Neutral) {\n if (\n self.rebalanceCache.healthParams.deltaBefore < self.deltaUpperLimit &&\n self.rebalanceCache.healthParams.deltaBefore > self.deltaLowerLimit\n ) revert Errors.InvalidRebalancePreConditions();\n } else if (rebalanceType == GMXTypes.RebalanceType.Debt) {\n if (\n self.rebalanceCache.healthParams.debtRatioBefore < self.debtRatioUpperLimit &&\n self.rebalanceCache.healthParams.debtRatioBefore > self.debtRatioLowerLimit\n ) revert Errors.InvalidRebalancePreConditions();\n } else {\n revert Errors.InvalidRebalanceParameters();\n }\n}\n```\n | low |
```\nfunction lastPublicMintingSale() external payable returns (bool) {\n if ((block.timestamp >= defaultSaleStartTime + DEFAULT_TEAMMINT_SALE)) {\n _tokenIds++;\n\n if (_tokenIds > DEFAULT_MAX_MINTING_SUPPLY)\n revert MaximumMintSupplyReached();\n\n if (lastPublicSale[msg.sender] >= LIMIT_IN_PUBLIC_SALE_PER_WALLET)\n revert MaximumMintLimitReachedByUser();\n\n if (dutchAuctionLastPrice != msg.value)\n revert InvalidBuyNFTPrice(dutchAuctionLastPrice, msg.value);\n\n lastPublicSale[msg.sender] = lastPublicSale[msg.sender] + 1;\n\n emit NewNFTMintedOnLastPublicSale(_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 |
```\nfunction _transfer(\n address from,\n address to,\n uint256 amount\n) internal override {\n require(from != address(0), "ERC20: transfer from the zero address");\n require(to != address(0), "ERC20: transfer to the zero address");\n require(!blocked[from], "Sniper blocked");\n\n if (amount == 0) {\n super._transfer(from, to, 0);\n return;\n }\n\n if (limitsInEffect) {\n if (\n from != owner() &&\n to != owner() &&\n to != address(0) &&\n to != address(0xdead) &&\n !swapping\n ) {\n if (!tradingActive) {\n require(\n _isExcludedFromFees[from] || _isExcludedFromFees[to],\n "Trading is not active."\n );\n }\n\n // at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.\n if (transferDelayEnabled) {\n if (\n to != owner() &&\n to != address(uniswapV2Router) &&\n to != address(uniswapV2Pair)\n ) {\n require(\n _holderLastTransferTimestamp[tx.origin] <\n block.number,\n "_transfer:: Transfer Delay enabled. Only one purchase per block allowed."\n );\n _holderLastTransferTimestamp[tx.origin] = block.number;\n }\n }\n\n //when buy\n if (\n automatedMarketMakerPairs[from] &&\n !_isExcludedmaxTransaction[to]\n ) {\n require(\n amount <= maxTransaction,\n "Buy transfer amount exceeds the maxTransaction."\n );\n require(\n amount + balanceOf(to) <= maxWallet,\n "Max wallet exceeded"\n );\n }\n //when sell\n else if (\n automatedMarketMakerPairs[to] &&\n !_isExcludedmaxTransaction[from]\n ) {\n require(\n amount <= maxTransaction,\n "Sell transfer amount exceeds the maxTransaction."\n );\n } else if (!_isExcludedmaxTransaction[to]) {\n require(\n amount + balanceOf(to) <= maxWallet,\n "Max wallet exceeded"\n );\n }\n }\n }\n\n uint256 contractTokenBalance = balanceOf(address(this));\n\n bool canSwap = contractTokenBalance >= swapTokensAtAmount;\n\n if (\n canSwap &&\n swapEnabled &&\n !swapping &&\n !automatedMarketMakerPairs[from] &&\n !_isExcludedFromFees[from] &&\n !_isExcludedFromFees[to]\n ) {\n swapping = true;\n\n swapBack();\n\n swapping = false;\n }\n\n bool takeFee = !swapping;\n\n // if any account belongs to _isExcludedFromFee account then remove the fee\n if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {\n takeFee = false;\n }\n\n uint256 fees = 0;\n // only take fees on buys/sells, do not take on wallet transfers\n if (takeFee) {\n // on sell\n if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {\n\n fees = amount.mul(sellTotalFees).div(100);\n tokensForLiquidity += (fees * sellLiquidityFee) / sellTotalFees;\n tokensForDevelopment += (fees * sellDevelopmentFee) / sellTotalFees;\n tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees; \n\n \n }\n // on buy\n else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {\n fees = amount.mul(buyTotalFees).div(100);\n tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;\n tokensForDevelopment += (fees * buyDevelopmentFee) / buyTotalFees;\n tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;\n }\n\n if (fees > 0) {\n \n super._transfer(from, address(this), fees);\n }\n\n amount -= fees;\n }\n\n super._transfer(from, to, amount);\n}\n```\n | none |
```\n// Check header chain length\nif (\_headers.length % 80 != 0) {return ERR\_BAD\_LENGTH;}\n```\n | low |
```\n function updateImpact(uint32 newImpact) external onlyOwner {\n emit UpdateImpact(impact, newImpact);\n impact = newImpact;\n }\n```\n | medium |
```\ncontract FortaStaking is BaseComponentUpgradeable, ERC1155SupplyUpgradeable, SubjectTypeValidator, ISlashingExecutor, IStakeMigrator {\n```\n | medium |
```\nActionInfo memory deleverInfo = _createAndValidateActionInfo(\n _setToken,\n _collateralAsset,\n _repayAsset,\n _redeemQuantityUnits,\n _minRepayQuantityUnits,\n _tradeAdapterName,\n false\n );\n```\n | medium |
```\nfunction stakeFor(address _for, uint256 _amount)\n public\n returns(bool)\n{\n _processStake(_amount, _for);\n\n //take away from sender\n stakingToken.safeTransferFrom(msg.sender, address(this), _amount);\n emit Staked(_for, _amount);\n \n return true;\n}\n```\n | high |
```\n/\*\*\n \* @dev Harvest additional yield from the investment.\n \* Only governance or strategist can call this function.\n \*/\nfunction harvest(address[] calldata \_tokens, uint256[] calldata \_cumulativeAmounts, uint256 \_index, uint256 \_cycle,\n```\n | 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. See MixinStakinPool for more information.\nuint256 constant internal POOL\_ID\_INCREMENT\_AMOUNT = 0x0000000000000000000000000000000100000000000000000000000000000000;\n```\n | low |
```\nconstructor() {\n _status = _NOT_ENTERED;\n}\n```\n | none |
```\n function _processPendingPosition(Context memory context, Position memory newPendingPosition) private {\n context.pendingCollateral = context.pendingCollateral\n .sub(newPendingPosition.fee)\n .sub(Fixed6Lib.from(newPendingPosition.keeper));\n \n context.closable = context.closable\n .sub(context.previousPendingMagnitude\n .sub(newPendingPosition.magnitude().min(context.previousPendingMagnitude)));\n context.previousPendingMagnitude = newPendingPosition.magnitude();\n\n if (context.previousPendingMagnitude.gt(context.maxPendingMagnitude))\n context.maxPendingMagnitude = newPendingPosition.magnitude();\n }\n```\n | medium |
```\n function _getCurrentSqrtPriceX96(\n bool zeroForA,\n address tokenA,\n address tokenB,\n uint24 fee\n ) private view returns (uint160 sqrtPriceX96) {\n if (!zeroForA) {\n (tokenA, tokenB) = (tokenB, tokenA);\n }\n address poolAddress = computePoolAddress(tokenA, tokenB, fee);\n (sqrtPriceX96, , , , , , ) = IUniswapV3Pool(poolAddress).slot0(); //@audit-issue can be easily manipulated\n }\n```\n | high |
```\n function withdrawToken(\n address from,\n address token,\n address receiver,\n uint256 sGlpAmount\n ) external returns (uint256 amountOut) {\n // user has approved periphery to use junior vault shares\n dnGmxJuniorVault.withdraw(sGlpAmount, address(this), from);\n// rest of code\n\n function redeemToken(\n address from,\n address token,\n address receiver,\n uint256 sharesAmount\n ) external returns (uint256 amountOut) {\n // user has approved periphery to use junior vault shares\n dnGmxJuniorVault.redeem(sharesAmount, address(this), from);\n// rest of code\n```\n | high |
```\ntransaction.data = abi.encodeWithSelector(\n IUniswapV2Router01.swapExactETHForTokens.selector,\n 0,\n path,\n msg.sender,\n type(uint256).max\n);\n```\n | medium |
```\nwhitelistingAddress = \_whitelistingAddress;\nprojectAddress = \_projectAddress;\nfreezerAddress = \_projectAddress; // TODO change, here only for testing\nrescuerAddress = \_projectAddress; // TODO change, here only for testing\n```\n | medium |
```\n require(IERC20(outputTokenAddress).balanceOf(address(this)) >= \n (totalAllocatedOutputToken - totalReleasedOutputToken), \n "INSUFFICIENT_OUTPUT_TOKEN");\n IERC20(inputTokenAddress).transferFrom(msg.sender, address(0), \n _inputTokenAmount);\n```\n | high |
```\nif (leaderboard.length == MAX\_LEADERBOARD\_SIZE.add(1)) {\n leaderboard.pop();\n}\n```\n | low |
```\nFile: GMXWithdraw.sol#processWithdraw\nself.vault.burn(self.withdrawCache.user, self.withdrawCache.withdrawParams.shareAmt);\n```\n | high |
Subsets and Splits