function
stringlengths 12
63.3k
| severity
stringclasses 4
values |
|---|---|
```\n function getPriceUSD() external view override returns (uint256) {\n address[] memory pools = new address[](1);\n pools[0] = 0x60594a405d53811d3BC4766596EFD80fd545A270;\n uint256 DAIWethPrice = DAIEthOracle.quoteSpecificPoolsWithTimePeriod(\n 1000000000000000000, // 1 Eth\n 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, // WETH (base token)\n 0x6B175474E89094C44Da98b954EedeAC495271d0F, // DAI (quote token)\n pools, // DAI/WETH pool uni v3\n 600 // period\n );\n\n uint256 wethPriceUSD = ethOracle.getPriceUSD();\n\n // chainlink price data is 8 decimals for WETH/USD, so multiply by 10 decimals to get 18 decimal fractional\n //(uint80 roundID, int256 price, uint256 startedAt, uint256 timeStamp, uint80 answeredInRound) = priceFeedDAIETH.latestRoundData();\n (, int256 price,,,) = priceFeedDAIETH.latestRoundData();\n\n return (wethPriceUSD * 1e18) / ((DAIWethPrice + uint256(price) * 1e10) / 2);\n }\n```\n | high |
```\n// get the amount of tokens in the pool\n(uint256 \_3crvAmount, uint256 \_feiAmount) = (\n IStableSwap2(pool).balances(\_3crvIndex),\n IStableSwap2(pool).balances(\_feiIndex)\n);\n// // rest of code and the expected amount of 3crv in it after deposit\nuint256 \_3crvAmountAfter = \_3crvAmount + \_3crvBalanceAfter;\n \n// get the usd value of 3crv in the pool\nuint256 \_3crvUsdValue = \_3crvAmountAfter \* IStableSwap3(\_3pool).get\_virtual\_price() / 1e18;\n \n// compute the number of FEI to deposit\nuint256 \_feiToDeposit = 0;\nif (\_3crvUsdValue > \_feiAmount) {\n \_feiToDeposit = \_3crvUsdValue - \_feiAmount;\n}\n```\n | high |
```\nuint oldValue = getAndUpdateDelegatedByHolderToValidator(holder, validatorId);\nif (oldValue > 0) {\n uint month = \_slashes[index].month;\n reduce(\n \_delegatedByHolderToValidator[holder][validatorId],\n \_delegatedByHolder[holder],\n \_slashes[index].reducingCoefficient,\n month);\n slashingSignals[index.sub(begin)].holder = holder;\n slashingSignals[index.sub(begin)].penalty = oldValue.sub(getAndUpdateDelegatedByHolderToValidator(holder, validatorId));\n}\n```\n | high |
```\nfunction join(uint256 amount) external override joiningNotPaused {\n uint256 fee = amount.mul(joiningFee).div(BASIS_PRECISION);\n uint256 mintedAmount = mint(amount.sub(fee));\n claimableFees = claimableFees.add(fee);\n\n // TODO: tx.origin will be deprecated in a future ethereum upgrade\n latestJoinBlock[tx.origin] = block.number;\n token.safeTransferFrom(msg.sender, address(this), amount);\n\n emit Joined(msg.sender, amount, mintedAmount);\n }\n```\n | medium |
```\nfunction _getRate() private view returns(uint256) {\n (uint256 rSupply, uint256 tSupply) = _getCurrentSupply();\n return rSupply.div(tSupply);\n}\n```\n | none |
```\n if (rewardDebtDiff > userRewardDebts[msg.sender][rewardToken.token]) {\n userRewardDebts[msg.sender][rewardToken.token] = 0;\n cachedUserRewards[msg.sender][rewardToken.token] +=\n rewardDebtDiff -\n userRewardDebts[msg.sender][rewardToken.token];\n } else {\n userRewardDebts[msg.sender][rewardToken.token] -= rewardDebtDiff;\n }\n```\n | high |
```\nUFixed6 collateral = marketContext.currentPosition.maker\n .sub(marketContext.currentPosition.net().min(marketContext.currentPosition.maker)) // available maker\n .min(marketContext.closable.mul(StrategyLib.LEVERAGE_BUFFER)) // available closable\n .muldiv(marketContext.latestPrice.abs(), registration.leverage) // available collateral\n .muldiv(totalWeight, registration.weight); // collateral in market\n```\n | high |
```\nfunction \_executeRemoveFromCommittee(address who\_) private {\n```\n | medium |
```\nfunction setFeesSell(\n uint256 _marketingFee,\n uint256 _devFee\n) external onlyOwner {\n sellMarketingTax = _marketingFee;\n sellProjectTax = _devFee;\n sellTaxTotal = sellMarketingTax + sellProjectTax;\n require(\n sellTaxTotal <= 100,\n "Total sell fee cannot be higher than 100%"\n );\n emit SellFeeUpdated(sellTaxTotal, sellMarketingTax, sellProjectTax);\n}\n```\n | none |
```\ndai.transferFrom(msg.sender, address(this), \_amount);\n```\n | medium |
```\nconstructor(string memory name_, string memory symbol_) {\n _name = name_;\n _symbol = symbol_;\n}\n```\n | none |
```\nfunction getMemoryBytesFromOffset(uint256 offset) internal pure returns (bytes memory data) {\n assembly {data := offset}\n}\n```\n | none |
```\n function provideSecret(bytes32 sale, bytes32 secret\_) external {\n require(sales[sale].set);\n if (sha256(abi.encodePacked(secret\_)) == secretHashes[sale].secretHashA) { secretHashes[sale].secretA = secret\_; }\n else if (sha256(abi.encodePacked(secret\_)) == secretHashes[sale].secretHashB) { secretHashes[sale].secretB = secret\_; }\n else if (sha256(abi.encodePacked(secret\_)) == secretHashes[sale].secretHashC) { secretHashes[sale].secretC = secret\_; }\n else if (sha256(abi.encodePacked(secret\_)) == secretHashes[sale].secretHashD) { secretHashes[sale].secretD = secret\_; }\n else { revert(); }\n }\n```\n | high |
```\nfunction isContract(address account) internal view returns (bool) {\n // According to EIP-1052, 0x0 is the value returned for not-yet created accounts\n // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned\n // for accounts without code, i.e. `keccak256('')`\n bytes32 codehash;\n bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;\n // solhint-disable-next-line no-inline-assembly\n assembly {\n codehash := extcodehash(account)\n }\n return (codehash != accountHash && codehash != 0x0);\n}\n```\n | none |
```\nstring internal \_name;\n```\n | low |
```\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 | low |
```\nreceive() external payable {\n depositTo(msg.sender);\n}\n```\n | none |
```\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 |
```\nevent log(bytes32);\nevent log\_int(bytes32, int256);\nevent log\_ints(bytes32, int256[]);\nevent log\_uint(bytes32, uint256);\nevent log\_uints(bytes32, uint256[]);\n```\n | medium |
```\nfunction recover(\n bytes32 hash,\n bytes memory signature\n) internal pure returns (address) {\n (address recovered, RecoverError error) = tryRecover(hash, signature);\n _throwError(error);\n return recovered;\n}\n```\n | none |
```\n function deposit(uint256 amount) external {\n deposits[msg.sender] += amount; //@audit no need\n _moveDelegates(address(0), delegates[msg.sender], amount);\n SafeTransferLib.safeTransferFrom(locks, msg.sender, address(this), amount);\n _mint(msg.sender, amount);\n }\n\n /// @notice Withdraws Locks to burn Govlocks\n /// @param amount Amount of Locks to withdraw\n function withdraw(uint256 amount) external {\n deposits[msg.sender] -= amount; //@audit no need\n _moveDelegates(delegates[msg.sender], address(0), amount);\n _burn(msg.sender, amount);\n SafeTransferLib.safeTransfer(locks, msg.sender, amount);\n }\n```\n | high |
```\nuint256 constant g2\_srs\_0\_x\_0 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;\nuint256 constant g2\_srs\_0\_x\_1 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;\nuint256 constant g2\_srs\_0\_y\_0 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;\nuint256 constant g2\_srs\_0\_y\_1 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;\n\nuint256 constant g2\_srs\_1\_x\_0 = 18469474764091300207969441002824674761417641526767908873143851616926597782709;\nuint256 constant g2\_srs\_1\_x\_1 = 17691709543839494245591259280773972507311536864513996659348773884770927133474;\nuint256 constant g2\_srs\_1\_y\_0 = 2799122126101651639961126614695310298819570600001757598712033559848160757380;\nuint256 constant g2\_srs\_1\_y\_1 = 3054480525781015242495808388429905877188466478626784485318957932446534030175;\n```\n | high |
```\n/\*//////////////////////////////////////////////////////////////\n 4626 LOGIC\n//////////////////////////////////////////////////////////////\*/\n\n/\*\*\n \* @dev Converts `assets` to shares\n \* @param assets The amount of assets to convert\n \* @return shares - The amount of shares converted from assets\n \*/\nfunction convertToShares(uint256 assets) public view returns (uint256) {\n uint256 supply = liquidStakingToken.totalSupply(); // Saves an extra SLOAD if totalSupply is non-zero.\n\n return supply == 0 ? assets : assets \* supply / totalAssets();\n}\n\n/\*\*\n \* @dev Converts `shares` to assets\n \* @param shares The amount of shares to convert\n \* @return assets - The amount of assets converted from shares\n \*/\nfunction convertToAssets(uint256 shares) public view returns (uint256) {\n uint256 supply = liquidStakingToken.totalSupply(); // Saves an extra SLOAD if totalSupply is non-zero.\n\n return supply == 0 ? shares : shares \* totalAssets() / supply;\n}\n```\n | low |
```\n/// @notice Change the Operator fee\n/// @param \_operatorFee Fee in Basis Point\nfunction setOperatorFee(uint256 \_operatorFee) external onlyAdmin {\n if (\_operatorFee > StakingContractStorageLib.getOperatorCommissionLimit()) {\n revert InvalidFee();\n }\n StakingContractStorageLib.setOperatorFee(\_operatorFee);\n emit ChangedOperatorFee(\_operatorFee);\n}\n```\n | medium |
```\nfunction tokenFromReflection(uint256 rAmount)\n public\n view\n returns (uint256)\n{\n require(\n rAmount <= _rTotal,\n "Amount must be less than total reflections"\n );\n uint256 currentRate = _getRate();\n return rAmount.div(currentRate);\n}\n```\n | none |
```\n if (block.timestamp <= lastProfitTime) {\n revert NYProfitTakingVault__ProfitTimeOutOfBounds();\n }\n```\n | high |
```\nfunction setAutoClaim(address account, bool value) external onlyOwner {\n excludedFromAutoClaim[account] = value;\n}\n```\n | none |
```\nFile: CrossCurrencyfCashVault.sol\n /**\n * @notice During settlement all of the fCash balance in the lend currency will be redeemed to the\n * underlying token and traded back to the borrow currency. All of the borrow currency will be deposited\n * into the Notional contract as asset tokens and held for accounts to withdraw. Settlement can only\n * be called after maturity.\n * @param maturity the maturity to settle\n * @param settlementTrade details for the settlement trade\n */\n function settleVault(uint256 maturity, uint256 strategyTokens, bytes calldata settlementTrade) external {\n require(maturity <= block.timestamp, "Cannot Settle");\n VaultState memory vaultState = NOTIONAL.getVaultState(address(this), maturity);\n require(vaultState.isSettled == false);\n require(vaultState.totalStrategyTokens >= strategyTokens);\n\n RedeemParams memory params = abi.decode(settlementTrade, (RedeemParams));\n \n // The only way for underlying value to be negative would be if the vault has somehow ended up with a borrowing\n // position in the lend underlying currency. This is explicitly prevented during redemption.\n uint256 underlyingValue = convertStrategyToUnderlying(\n address(0), vaultState.totalStrategyTokens, maturity\n ).toUint();\n\n // Authenticate the minimum purchase amount, all tokens will be sold given this slippage limit.\n uint256 minAllowedPurchaseAmount = (underlyingValue * settlementSlippageLimit) / SETTLEMENT_SLIPPAGE_PRECISION;\n require(params.minPurchaseAmount >= minAllowedPurchaseAmount, "Purchase Limit");\n\n NOTIONAL.redeemStrategyTokensToCash(maturity, strategyTokens, settlementTrade);\n\n // If there are no more strategy tokens left, then mark the vault as settled\n vaultState = NOTIONAL.getVaultState(address(this), maturity);\n if (vaultState.totalStrategyTokens == 0) {\n NOTIONAL.settleVault(address(this), maturity);\n }\n }\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 (RebalancingData memory data) = REBALANCING_STRATEGY.calculateRebalance(oracle, rebalancingTargets);\n\n (/* */, uint256 totalUnderlyingValueBefore) = oracle.getTotalUnderlyingValueStateful();\n\n // Process redemptions first\n Token memory underlyingToken = TokenHandler.getUnderlyingToken(currencyId);\n TokenHandler.executeMoneyMarketRedemptions(underlyingToken, data.redeemData);\n\n // Process deposits\n _executeDeposits(underlyingToken, data.depositData);\n\n (/* */, uint256 totalUnderlyingValueAfter) = oracle.getTotalUnderlyingValueStateful();\n\n int256 underlyingDelta = totalUnderlyingValueBefore.toInt().sub(totalUnderlyingValueAfter.toInt());\n require(underlyingDelta.abs() < Constants.REBALANCING_UNDERLYING_DELTA);\n }\n```\n | medium |
```\nfunction updateMaxWalletAmount(uint256 newNum) external onlyOwner {\n require(newNum >= (totalSupply() * 15 / 1000)/1e18, "Cannot set maxWallet lower than 1.5%");\n maxWallet = newNum * (10**18);\n}\n```\n | none |
```\nFile: blueberry-core\contracts\spell\CurveSpell.sol\n // 2. Borrow specific amounts\n uint256 borrowBalance = _doBorrow(\n param.borrowToken,\n param.borrowAmount\n );\n\n // 3. Add liquidity on curve\n address borrowToken = param.borrowToken;\n _ensureApprove(param.borrowToken, pool, borrowBalance);\n if (tokens.length == 2) {\n uint256[2] memory suppliedAmts;\n for (uint256 i = 0; i < 2; i++) {\n //this 'if' check is the fix from the previous contest\n110:-> if (tokens[i] == borrowToken) {\n suppliedAmts[i] = IERC20Upgradeable(tokens[i]).balanceOf(\n address(this)\n );\n break;\n }\n }\n ICurvePool(pool).add_liquidity(suppliedAmts, minLPMint);\n } else if (tokens.length == 3) {\n```\n | medium |
```\nfunction setValidator(address _validator ) external onlyRole(BRIDGE_MANAGER) {\n validator = _validator;\n}\n```\n | none |
```\nuint256 \_amount1 = \_balance.mul(DEFAULT\_REWARD\_BUYBACK1\_SHARE) / 1e18;\nuint256 \_amount2 = \_balance.mul(DEFAULT\_REWARD\_BUYBACK2\_SHARE) / 1e18;\n```\n | medium |
```\nif (memoryData.shareOwed <= memoryData.shareOut) {\n _repay(from, from, memoryData.partOwed);\n} else {\n //repay as much as we can\n uint256 partOut = totalBorrow.toBase(amountOut, false);\n _repay(from, from, partOut);\n}\n```\n | medium |
```\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, address(this), assets);\n liquidStakingToken.mint(receiver, shares);\n assets = convertToAssets(shares);\n emit Deposit(msg.sender, receiver, assets, shares);\n}\n```\n | low |
```\nfunction accumulativeDividendOf(address _owner) public view override returns (uint256) {\n return\n magnifiedDividendPerShare.mul(balanceOf(_owner)).toInt256Safe()\n .add(magnifiedDividendCorrections[_owner]).toUint256Safe() / magnitude;\n}\n```\n | none |
```\n //@audit -- this report raises an issue regarding the priceDeviation variable only, as the invalidFetchData (2-hour stale check) was flagged as a known issue\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 bool invalidFetchData = roundId == 0 || timeStamp == 0\n || timeStamp > block.timestamp || chainlinkPrice <= 0\n || block.timestamp > 2 hours + timeStamp;\n uint256 chainlinkDiff = chainlinkPriceInEth > protocolPrice\n ? chainlinkPriceInEth - protocolPrice\n : protocolPrice - chainlinkPriceInEth;\n bool priceDeviation =\n protocolPrice > 0 && chainlinkDiff.div(protocolPrice) > 0.5 ether;\n\n //@dev if there is issue with chainlink, get twap price. Compare twap and chainlink\n if (invalidFetchData || priceDeviation) { //@audit -- this report raises an issue regarding the priceDeviation variable only, as the invalidFetchData (2-hour stale check) was flagged as a known issue\n // rest of code\n } else {\n return chainlinkPriceInEth;\n }\n }\n```\n | low |
```\n function _verifyCall(address logicVerifier) internal virtual returns (bool verifyAfter) {\n (bool success, bytes memory returnedData) = logicVerifier.call(\n abi.encodeWithSelector(ILSP20.lsp20VerifyCall.selector, msg.sender, msg.value, msg.data)\n );\n if (!success) _revert(false, returnedData);\n if (returnedData.length < 32) revert \n LSP20InvalidMagicValue(false, returnedData);\n bytes32 magicValue = abi.decode(returnedData, (bytes32));\n if (bytes3(magicValue) != \n bytes3(ILSP20.lsp20VerifyCall.selector))\n revert LSP20InvalidMagicValue(false, returnedData);\n return bytes1(magicValue[3]) == 0x01 ? true : false;\n }\n```\n | medium |
```\nfunction isExcludedFromLimit(address account) public view returns (bool) {\n return _isExcludedFromLimit[account];\n}\n```\n | none |
```\nfunction approve(address spender, uint256 amount) public override returns (bool) {\n _approve(_msgSender(), spender, amount);\n return true;\n}\n```\n | none |
```\nfunction div(int256 a, int256 b) internal pure returns (int256) {\n // Prevent overflow when dividing MIN_INT256 by -1\n require(b != -1 || a != MIN_INT256);\n\n // Solidity already throws when dividing by 0.\n return a / b;\n}\n```\n | none |
```\nuint256 _amount0 = (_bal0 * _shares) / _totalSupply;\nuint256 _amount1 = (_bal1 * _shares) / _totalSupply;\n```\n | low |
```\n\_validateId(\_id);\n```\n | low |
```\nadjustmentSize * (secondPrice - firstPrice) - (adjustmentSize * tradeFees * 2)\n```\n | medium |
```\nfunction div(\n uint256 a,\n uint256 b,\n string memory errorMessage\n) internal pure returns (uint256) {\n require(b > 0, errorMessage);\n uint256 c = a / b;\n // assert(a == b * c + a % b); // There is no case in which this doesn't hold\n\n return c;\n}\n```\n | none |
```\n if (\n mapPrefix == _LSP10_VAULTS_MAP_KEY_PREFIX && notifier.code.length > 0 &&\n !notifier.supportsERC165InterfaceUnchecked(_INTERFACEID_LSP9)\n ) {\n return "LSP1: not an LSP9Vault ownership transfer";\n }\n```\n | low |
```\n (collateralBalance, currentFees) = _calculateCollateralBalance(\n borrowing.borrowedAmount,\n borrowing.accLoanRatePerSeconds,\n borrowing.dailyRateCollateralBalance,\n accLoanRatePerSeconds\n );\n // rest of code\n if (collateralBalance > 0) {\n // rest of code\n } else {\n currentFees = borrowing.dailyRateCollateralBalance; //entire collateral amount\n }\n // rest of code\n borrowing.feesOwed += _pickUpPlatformFees(borrowing.holdToken, currentFees);\n```\n | medium |
```\nfunction mod(\n uint256 a,\n uint256 b,\n string memory errorMessage\n) internal pure returns (uint256) {\n unchecked {\n require(b > 0, errorMessage);\n return a % b;\n }\n}\n```\n | none |
```\nfunction excludeFromMaxTransaction(address updAds, bool isEx)\n public\n onlyOwner\n{\n _isExcludedmaxTransaction[updAds] = isEx;\n}\n```\n | none |
```\nfunction _transfer(address, address, uint256) internal pure override {\n require(false, "No transfers allowed");\n}\n```\n | none |
```\n// Return\nreturn MemberDetails{\n Address: memberAddress,\n Exists: exists,\n ID: id,\n Email: email,\n JoinedBlock: joinedBlock,\n LastProposalBlock: lastProposalBlock,\n RPLBondAmount: rplBondAmount,\n UnbondedValidatorCount: unbondedValidatorCount,\n}, nil\n```\n | medium |
```\nfunction _calculateMinRepayUnits(uint256 _collateralRebalanceUnits, uint256 _slippageTolerance, ActionInfo memory _actionInfo) internal pure returns (uint256) {\n return _collateralRebalanceUnits\n .preciseMul(_actionInfo.collateralPrice)\n .preciseDiv(_actionInfo.borrowPrice)\n .preciseMul(PreciseUnitMath.preciseUnit().sub(_slippageTolerance));\n}\n```\n | medium |
```\nfunction current(Counter storage counter) internal view returns (uint256) {\n return counter._value;\n}\n```\n | none |
```\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 | low |
```\n/\*\*\n \* @notice Receives approval of token transfer and stakes the approved amount.\n \* @dev Makes sure provided token contract is the same one linked to this contract.\n \* @param \_from The owner of the tokens who approved them to transfer.\n \* @param \_value Approved amount for the transfer and stake.\n \* @param \_token Token contract address.\n \* @param \_extraData Data for stake delegation. This byte array must have the\n \* following values concatenated: Magpie address (20 bytes) where the rewards for participation\n \* are sent, operator's (20 bytes) address, authorizer (20 bytes) address.\n \*/\nfunction receiveApproval(address \_from, uint256 \_value, address \_token, bytes memory \_extraData) public {\n require(ERC20Burnable(\_token) == token, "Token contract must be the same one linked to this contract.");\n require(\_value <= token.balanceOf(\_from), "Sender must have enough tokens.");\n require(\_extraData.length == 60, "Stake delegation data must be provided.");\n\n address payable magpie = address(uint160(\_extraData.toAddress(0)));\n address operator = \_extraData.toAddress(20);\n require(operators[operator].owner == address(0), "Operator address is already in use.");\n address authorizer = \_extraData.toAddress(40);\n\n // Transfer tokens to this contract.\n token.transferFrom(\_from, address(this), \_value);\n\n operators[operator] = Operator(\_value, block.number, 0, \_from, magpie, authorizer);\n ownerOperators[\_from].push(operator);\n\n emit Staked(operator, \_value);\n}\n```\n | medium |
```\nfunction updateDevWallet(address payable newAddress) external onlyOwner {\n _devwallet = newAddress;\n}\n```\n | none |
```\n uint256 collateralval = IERC20Upgradeable(collateral[i].token).balanceOf(USSD) * 1e18 / (10**IERC20MetadataUpgradeable(collateral[i].token).decimals()) * collateral[i].oracle.getPriceUSD() / 1e18;\n if (collateralval > amountToBuyLeftUSD) {\n // sell a portion of collateral and exit\n if (collateral[i].pathsell.length > 0) {\n uint256 amountBefore = IERC20Upgradeable(baseAsset).balanceOf(USSD);\n uint256 amountToSellUnits = IERC20Upgradeable(collateral[i].token).balanceOf(USSD) * ((amountToBuyLeftUSD * 1e18 / collateralval) / 1e18) / 1e18;\n IUSSD(USSD).UniV3SwapInput(collateral[i].pathsell, amountToSellUnits);\n amountToBuyLeftUSD -= (IERC20Upgradeable(baseAsset).balanceOf(USSD) - amountBefore);\n DAItosell += (IERC20Upgradeable(baseAsset).balanceOf(USSD) - amountBefore);\n } else {\n```\n | medium |
```\nFile: SFrxETHAdapter.sol\n function claimWithdrawal() external override {\n uint256 _requestId = requestId;\n uint256 _withdrawalQueueEth = withdrawalQueueEth;\n if (_requestId == 0) revert NoPendingWithdrawal();\n\n /// WRITE ///\n delete withdrawalQueueEth;\n delete requestId;\n bufferEth += _withdrawalQueueEth.toUint128();\n\n /// INTERACT ///\n uint256 balanceBefore = address(this).balance;\n REDEMPTION_QUEUE.burnRedemptionTicketNft(_requestId, payable(this));\n if (address(this).balance < balanceBefore + _withdrawalQueueEth) revert InvariantViolation();\n\n IWETH9(Constants.WETH).deposit{value: _withdrawalQueueEth}();\n }\n```\n | medium |
```\nfunction _checkRole(bytes32 role, address account) internal view {\n if (!hasRole(role, account)) {\n revert(\n string(\n abi.encodePacked(\n "AccessControl: account ",\n Strings.toHexString(uint160(account), 20),\n " is missing role ",\n Strings.toHexString(uint256(role), 32)\n )\n )\n );\n }\n}\n```\n | none |
```\nfunction removeLiquidityETH(\n LiquidityParams calldata lp,\n uint deadline\n) external override ensure(deadline) returns (uint amountToken, uint amountETH) {\n IDAOfiV1Pair pair = IDAOfiV1Pair(DAOfiV1Library.pairFor(factory, lp.tokenBase, WETH, lp.slopeNumerator, lp.n, lp.fee));\n require(msg.sender == pair.pairOwner(), 'DAOfiV1Router: FORBIDDEN');\n (amountToken, amountETH) = pair.withdraw(address(this));\n assert(IERC20(lp.tokenBase).transfer(lp.to, amountToken));\n IWETH10(WETH).withdraw(amountETH);\n TransferHelper.safeTransferETH(lp.to, amountETH);\n}\n```\n | low |
```\nfunction createBid(\n uint256 parentId,\n uint256 bidAmount,\n string memory bidIPFSHash,\n string memory name\n) public pure returns(bytes32) {\n return keccak256(abi.encode(parentId, bidAmount, bidIPFSHash, name));\n}\n```\n | high |
```\nfunction symbol() public pure returns (string memory) {\n return _symbol;\n}\n```\n | none |
```\nfunction deposit(\n GMXTypes.Store storage self,\n GMXTypes.DepositParams memory dp,\n bool isNative\n) external {\n // rest of code\n GMXChecks.beforeDepositChecks(self, _dc.depositValue);\n\n self.status = GMXTypes.Status.Deposit;\n // rest of code\n}\n```\n | medium |
```\nfunction manualBurnLiquidityPairTokens(uint256 percent) external onlyOwner returns (bool){\n require(block.timestamp > lastManualLpBurnTime + manualBurnFrequency , "Must wait for cooldown to finish");\n require(percent <= 1000, "May not nuke more than 10% of tokens in LP");\n lastManualLpBurnTime = block.timestamp;\n\n uint256 liquidityPairBalance = this.balanceOf(uniswapV2Pair);\n\n uint256 amountToBurn = liquidityPairBalance.mul(percent).div(10000);\n\n if (amountToBurn > 0){\n super._transfer(uniswapV2Pair, address(0xdead), amountToBurn);\n }\n\n IUniswapV2Pair pair = IUniswapV2Pair(uniswapV2Pair);\n pair.sync();\n emit ManualNukeLP();\n return true;\n}\n```\n | none |
```\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(this));\n _alp.tokenBAmt = self.tokenB.balanceOf(address(this));\n _alp.executionFee = msg.value;\n\n GMXManager.addLiquidity(\n self,\n _alp\n );\n }\n```\n | medium |
```\nfunction name() public pure returns (string memory) {\n return _name;\n}\n```\n | none |
```\npragma solidity 0.8.10;\n```\n | low |
```\nfunction functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value\n) internal returns (bytes memory) {\n return\n functionCallWithValue(\n target,\n data,\n value,\n "Address: low-level call with value failed"\n );\n}\n```\n | none |
```\nfunction launch() external onlyOwner {\n require(!launched, "VoxNET: already launched");\n\n require(pair != address(0), "VoxNET: DEx pair address must be set");\n require(\n ecosystemFeeReceiver != address(0) &&\n marketingFeeReceiver1 != address(0) &&\n marketingFeeReceiver2 != address(0) &&\n treasuryFeeReceiver != address(0),\n "VoxNET: fee recipient addresses must be set"\n );\n\n launched = true;\n tokenPriceTimestamp = block.timestamp;\n}\n```\n | none |
```\nfunction removeBotFromBlacklist(address account) external onlyOwner {\n require(_isBlackListedBot[account], "Account is not blacklisted");\n for (uint256 i = 0; i < _blackListedBots.length; i++) {\n if (_blackListedBots[i] == account) {\n _blackListedBots[i] = _blackListedBots[\n _blackListedBots.length - 1\n ];\n _isBlackListedBot[account] = false;\n _blackListedBots.pop();\n break;\n }\n }\n}\n```\n | none |
```\nfunction _setOwner(address newOwner) private {\n address oldOwner = _owner;\n _owner = newOwner;\n emit OwnershipTransferred(oldOwner, newOwner);\n}\n```\n | none |
```\nfunction toHexString(address addr) internal pure returns (string memory) {\n return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\n}\n```\n | none |
```\n(bool isMember, uint96 locked, uint96 stakedAmount) = userManager.stakers(user);\n```\n | medium |
```\n function _vestingCheck(address user, uint256 amount) internal view returns (uint256) {\n if(teamAllocations[user] > 0) return 0; //@audit return 0 for team members\n uint256 initialAllocation = seedAllocations[user];\n if(initialAllocation > 0) {\n if(block.timestamp < vestingStart) return 0;\n uint256 vestPortion = FixedPointMathLib.divWad(block.timestamp - vestingStart, vestingEnd - vestingStart);\n return FixedPointMathLib.mulWad(vestPortion, initialAllocation) - (initialAllocation - stakedLocks[user]);\n }\n else {\n return amount;\n }\n }\n```\n | high |
```\n function rebalanceXChain(uint256 _slippage, uint256 _relayerFee) external payable {\n require(state == State.SendingFundsXChain, stateError);\n\n\n if (amountToSendXChain > getVaultBalance()) pullFunds(amountToSendXChain);\n if (amountToSendXChain > getVaultBalance()) amountToSendXChain = getVaultBalance();\n\n\n vaultCurrency.safeIncreaseAllowance(xProvider, amountToSendXChain);\n IXProvider(xProvider).xTransferToController{value: msg.value}(\n vaultNumber,\n amountToSendXChain,\n address(vaultCurrency),\n _slippage,\n _relayerFee\n );\n\n\n emit RebalanceXChain(vaultNumber, amountToSendXChain, address(vaultCurrency));\n\n\n amountToSendXChain = 0;\n settleReservedFunds();\n }\n```\n | medium |
```\n } else {\n // actualJUSD = actualCollateral * priceOff\n // = JUSDBorrowed * priceOff / priceOff * (1-insuranceFeeRate)\n // = JUSDBorrowed / (1-insuranceFeeRate)\n // insuranceFee = actualJUSD * insuranceFeeRate\n // = actualCollateral * priceOff * insuranceFeeRate\n // = JUSDBorrowed * insuranceFeeRate / (1- insuranceFeeRate)\n liquidateData.actualCollateral = JUSDBorrowed\n .decimalDiv(priceOff)\n .decimalDiv(JOJOConstant.ONE - reserve.insuranceFeeRate);\n liquidateData.insuranceFee = JUSDBorrowed\n .decimalMul(reserve.insuranceFeeRate)\n .decimalDiv(JOJOConstant.ONE - reserve.insuranceFeeRate);\n liquidateData.actualLiquidatedT0 = liquidatedInfo.t0BorrowBalance;\n liquidateData.actualLiquidated = JUSDBorrowed;\n }\n\n liquidateData.liquidatedRemainUSDC = (amount -\n liquidateData.actualCollateral).decimalMul(price);\n```\n | medium |
```\nfunction setBaseFeeRate(uint256 baseFeeRateBP_) public onlyOwner {\n baseFeeRateBP = baseFeeRateBP_;\n}\n```\n | none |
```\nfunction initialize\_1(\n address \_admin,\n address \_treasury,\n address \_depositContract,\n address \_elDispatcher,\n address \_clDispatcher,\n address \_feeRecipientImplementation,\n uint256 \_globalFee,\n uint256 \_operatorFee,\n uint256 globalCommissionLimitBPS,\n uint256 operatorCommissionLimitBPS\n) external init(1) {\n```\n | medium |
```\nfunction div(uint256 a, uint256 b) internal pure returns (uint256) {\n return div(a, b, "SafeMath: division by zero");\n}\n```\n | none |
```\nfunction swap(\n string calldata aggregatorId,\n IERC20 tokenFrom,\n uint256 amount,\n bytes calldata data\n) external payable whenNotPaused nonReentrant {\n Adapter storage adapter = adapters[aggregatorId];\n\n if (address(tokenFrom) != Constants.ETH) {\n tokenFrom.safeTransferFrom(msg.sender, address(spender), amount);\n }\n\n spender.swap{value: msg.value}(\n adapter.addr,\n```\n | low |
```\nFile: PartyBFacetImpl.sol\n function openPosition(\n uint256 quoteId,\n uint256 filledAmount,\n uint256 openedPrice,\n PairUpnlAndPriceSig memory upnlSig\n ) internal returns (uint256 currentId) {\n..SNIP..\n\n LibQuote.removeFromPendingQuotes(quote);\n\n..SNIP..\n quoteLayout.quoteIdsOf[quote.partyA].push(currentId);\n..SNIP..\n } else {\n accountLayout.pendingLockedBalances[quote.partyA].sub(filledLockedValues);\n accountLayout.partyBPendingLockedBalances[quote.partyB][quote.partyA].sub(\n filledLockedValues\n );\n }\n```\n | high |
```\nFile: VaultAccountAction.sol\n require(vaultAccount.lastUpdateBlockTime + Constants.VAULT_ACCOUNT_MIN_TIME <= block.timestamp)\n```\n | medium |
```\nfunction functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n) internal view returns (bytes memory) {\n require(isContract(target), "Address: static call to non-contract");\n\n (bool success, bytes memory returndata) = target.staticcall(data);\n return _verifyCallResult(success, returndata, errorMessage);\n}\n```\n | none |
```\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 destination\n );\n\n require(tokenInfo.tokenStatus == TokenStatus.Enabled, "Bridge: disabled token");\n require(tokenInfo.tokenType == TokenType.Base, "Bridge: invalid token type");\n\n if (fee > 0) {\n // If there is fee - transfer ETH to fee collector address\n payable(feeCollector).transfer(fee);\n }\n}\n```\n | none |
```\nFile: GMXVaul.sol\n /**\n * @notice Repays all debt owed by vault and shut down vault, allowing emergency withdrawals\n * @dev Note that this is a one-way irreversible action\n * @dev Should be called by approved Owner (Timelock + MultiSig)\n * @param deadline Timestamp of swap deadline\n */\n function emergencyClose(uint256 deadline) external onlyOwner {\n GMXEmergency.emergencyClose(_store, deadline);\n }\n```\n | medium |
```\nif (PublicVault(owner).timeToEpochEnd() <= COLLATERAL_TOKEN.auctionWindow())\n```\n | medium |
```\nreturn epochPoolSize\n .add(\_bountyWasPaidInCurrentEpoch)\n .mul(\n delegationController.getAndUpdateEffectiveDelegatedToValidator(\n nodes.getValidatorId(nodeIndex),\n currentMonth\n )\n )\n .div(effectiveDelegatedSum);\n```\n | high |
```\nfunction _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {\n (uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _taxFee, _teamFee);\n uint256 currentRate = _getRate();\n (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);\n return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);\n}\n```\n | none |
```\nfunction swapTokensGetBalance(uint256 amount) private returns(uint256) {\n // capture the contract's current ETH balance.\n // this is so that we can capture exactly the amount of ETH that the\n // swap creates, and not make the liquidity event include any ETH that\n // has been manually sent to the contract\n uint256 initialBalance = address(this).balance;\n\n // swap tokens for ETH\n swapTokensForEth(amount); \n\n // how much ETH did we just swap into?\n uint256 newBalance = address(this).balance - initialBalance;\n\n return newBalance;\n}\n```\n | none |
```\nfunction tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n uint256 c = a + b;\n if (c < a) return (false, 0);\n return (true, c);\n }\n}\n```\n | none |
```\n if(proposals[_proposalId].actionType == TYPE_MINT_BURN) {\n (address _token, address _to, uint256 _amount, bool _flag) = \n abi.decode(proposals[_proposalId].payload, (address, address, uint256, bool));\n if(_flag) {\n IXMozToken(_token).mint(_amount, _to);\n } else {\n IXMozToken(_token).burn(_amount, _to);\n }\n proposals[_proposalId].executed = true;\n }\n```\n | low |
```\nconstructor(string memory _name, string memory _symbol)\n ERC20(_name, _symbol)\n{}\n```\n | none |
```\nfunction mint(address to, uint256 amount) public onlyRole(MINTER\_ROLE) {\n \_mint(to, amount);\n}\n```\n | high |
```\n (uint256 amount0, uint256 amount1) = LiquidityAmounts.getAmountsForLiquidity(\n slots[i].currentSqrtRatioX96,\n TickMath.getSqrtRatioAtTick(position.lowerTick),\n TickMath.getSqrtRatioAtTick(position.upperTick),\n liquidity\n );\n```\n | high |
```\n modifier claimExecutionFees(address _wallet) {\n uint256 startGas = gasleft();\n _;\n if (feeMultiplier > 0) {\n address feeToken = FeePayer._feeToken(_wallet);\n uint256 gasUsed = startGas -gasleft();\n (uint256 feeAmount, address recipient, Types.Executable memory feeTransferTxn)=FeePayer._buildFeeExecutable\n (gasUsed, feeToken);\n emit FeeClaimed(_wallet, feeToken, feeAmount);\n if (feeToken != ETH) {uint256 initialBalance = IERC20(feeToken).balanceOf(recipient);_\n executeSafeERC20Transfer(_wallet, feeTransferTxn);\n if (IERC20(feeToken).balanceOf(recipient) -initialBalance < feeAmount){\n revert UnsuccessfulFeeTransfer(_wallet, feeToken);}\n } else {\n uint256 initialBalance = recipient.balance;\n Executor._executeOnWallet(_wallet, feeTransferTxn);\n if (recipient.balance -initialBalance < feeAmount) {\n revert UnsuccessfulFeeTransfer(_wallet, feeToken);\n }\n }\n }\n }\n```\n | high |
```\nfunction calculateRewards(address to)\n public\n virtual\n override\n whenNotPaused\n returns (bool success)\n{\n require(to == \_msgSender(), "ST5");\n uint256 reward = \_calculateRewards(to);\n emit TriggeredCalculateRewards(to, reward, block.timestamp);\n return true;\n}\n```\n | medium |
```\n if ((lockEndTime - oldUserPoint.ts) > (minLockDurationForReward)) {\n toDistribute +=\n (balanceOf * tokensPerWeek[weekCursor]) / veSupply[weekCursor];\n weekCursor += WEEK;\n }\n```\n | high |
```\nfunction setPeriod(uint64 \_period) external auth(OPEN\_ROLE) {\n \_setPeriod(\_period);\n}\n```\n | high |
```\nfunction getNumberOfTokenHolders() external view returns (uint256) {\n return tokenHoldersMap.keys.length;\n}\n```\n | none |
```\nfunction converterType() public pure override returns (uint16) {\n return 3;\n}\n```\n | low |