function
stringlengths 12
63.3k
| severity
stringclasses 4
values |
|---|---|
```\nfunction unlockExchange() external onlyAdmin() {\n DFPconfig.unlocked = true;\n}\n```\n | none |
```\nfunction _calculateQuoteAssetQuantity(bool isSellAuction, uint256 _componentQuantity, uint256 _componentPrice) private pure returns (uint256) {\n return isSellAuction ? _componentQuantity.preciseMulCeil(_componentPrice) : _componentQuantity.preciseMul(_componentPrice);\n}\n```\n | medium |
```\n try priceFeedA.latestRoundData() returns (\n uint80,\n int256 price,\n uint256,\n uint256 updatedAt,\n uint80\n ) {\n require(\n block.timestamp - updatedAt <= outdated, // solhint-disable-line not-rely-on-time\n "ChainLinkOracle: priceFeedA outdated."\n );\n\n priceA = SafeCast.toUint256(price);\n } catch {\n revert("ChainLinkOracle: price feed A call failed.");\n }\n\n try priceFeedB.latestRoundData() returns (\n uint80,\n int256 price,\n uint256,\n uint256 updatedAt,\n uint80\n ) {\n require(\n block.timestamp - updatedAt <= outdated, // solhint-disable-line not-rely-on-time\n "ChainLinkOracle: priceFeedB outdated."\n );\n\n priceB = SafeCast.toUint256(price);\n } catch {\n revert("ChainLinkOracle: price feed B call failed.");\n }\n```\n | medium |
```\n if (isCurrencyAllowed[tokenAddress] != 1) {\n revert InvalidCollection();\n }\n```\n | high |
```\nshares = totalSupply() > 0\n ? (totalSupply() \* amountIn) / totalVaultFunds()\n : amountIn;\n```\n | medium |
```\nfunction _validateSigner(\n uint256 timestamp,\n address asset,\n uint256 price,\n bytes memory signature\n) internal view returns (bool) {\n bytes32 digest = ECDSA.toEthSignedMessageHash(\n keccak256(abi.encodePacked(timestamp, asset, price))\n );\n address recoveredSigner = ECDSA.recover(digest, signature);\n return recoveredSigner == publisher;\n}\n```\n | medium |
```\nfunction handleOps(UserOperation[] calldata ops, address payable beneficiary) public nonReentrant {\n\n uint256 opslen = ops.length;\n UserOpInfo[] memory opInfos = new UserOpInfo[](opslen);\n\nunchecked {\n for (uint256 i = 0; i < opslen; i++) {\n UserOpInfo memory opInfo = opInfos[i];\n (uint256 validationData, uint256 pmValidationData) = _validatePrepayment(i, ops[i], opInfo);\n _validateAccountAndPaymasterValidationData(i, validationData, pmValidationData, address(0));\n }\n\n uint256 collected = 0;\n emit BeforeExecution();\n\n for (uint256 i = 0; i < opslen; i++) {\n collected += _executeUserOp(i, ops[i], opInfos[i]);\n }\n\n _compensate(beneficiary, collected);\n} //unchecked\n}\n```\n | none |
```\nfunction changeProjectWallet(address newWallet) external onlyOwner {\n emit ProjectWalletUpdated(newWallet, projectWallet);\n projectWallet = newWallet;\n}\n```\n | none |
```\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 |
```\ncelerStorageWrapper.setAddressForTransferId(transferId, msg.sender);\n```\n | medium |
```\nif (firstBidTime + duration - block.timestamp < timeBuffer)\n```\n | medium |
```\nfunction _functionCallWithValue(\n address target,\n bytes memory data,\n uint256 weiValue,\n string memory errorMessage\n) private returns (bytes memory) {\n require(isContract(target), "Address: call to non-contract");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.call{value: weiValue}(\n data\n );\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 // The easiest way to bubble the revert reason is using memory via assembly\n\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n}\n```\n | none |
```\n receive() external payable {}\n```\n | low |
```\n vault.updateStableCollateralTotal(-int256(_amountOut));\n```\n | medium |
```\nrequire(\_numberOfWinners > 0, "MultipleWinners/num-gt-zero");\n```\n | medium |
```\nfunction toUint256Safe(int256 a) internal pure returns (uint256) {\n require(a >= 0);\n return uint256(a);\n}\n```\n | none |
```\nfunction updateExchangeWallet(address newAddress) external onlyOwner {\n _exchangewallet = newAddress;\n}\n```\n | none |
```\n //E Burn vusd from msg.sender and queue the withdrawal to "to" address\n function _withdrawTo(address to, uint amount) internal {\n //E check min amount\n require(amount >= 5 * (10 ** 6), "min withdraw is 5 vusd"); //E @audit-info not enough to prevent grief\n //E burn this amount from msg.sender\n burn(amount); // burn vusd from msg.sender\n //E push \n withdrawals.push(Withdrawal(to, amount * 1e12));\n }\n```\n | medium |
```\n while (_quantity > 0) {\n Receipt memory deposit = deposits[i];\n if (deposit.amount == 0) {\n i++;\n continue;\n }\n if (deposit.amount <= _quantity) {\n // deposit amount is lesser than quantity use it fully\n _quantity = _quantity - deposit.amount;\n usdBalance[deposit.sender] -= deposit.amount;\n amountToSend = (deposit.amount * 1e18) / _price;\n IERC20(crab).transfer(deposit.sender, amountToSend);\n emit USDCDeposited(deposit.sender, deposit.amount, amountToSend, i, 0);\n delete deposits[i];\n i++;\n } else {\n // deposit amount is greater than quantity; use it partially\n deposits[i].amount = deposit.amount - _quantity;\n usdBalance[deposit.sender] -= _quantity;\n amountToSend = (_quantity * 1e18) / _price;\n IERC20(crab).transfer(deposit.sender, amountToSend);\n emit USDCDeposited(deposit.sender, _quantity, amountToSend, i, 0);\n _quantity = 0;\n }\n }\n```\n | high |
```\nimport { expect } from "chai";\n\nimport { deployContract } from "../../utils/deploy";\nimport { deployFixture } from "../../utils/fixture";\nimport {\n TOKEN_ORACLE_TYPES,\n signPrices,\n getSignerInfo,\n getCompactedPrices,\n getCompactedPriceIndexes,\n getCompactedDecimals,\n getCompactedOracleBlockNumbers,\n getCompactedOracleTimestamps,\n} from "../../utils/oracle";\nimport { printGasUsage } from "../../utils/gas";\nimport { grantRole } from "../../utils/role";\nimport * as keys from "../../utils/keys";\n\ndescribe("AttackOracle", () => {\n const { provider } = ethers;\n\n let user0, signer0, signer1, signer2, signer3, signer4, signer7, signer9;\n let roleStore, dataStore, eventEmitter, oracleStore, oracle, wnt, wbtc, usdc;\n let oracleSalt;\n\n beforeEach(async () => {\n const fixture = await deployFixture();\n ({ user0, signer0, signer1, signer2, signer3, signer4, signer7, signer9 } = fixture.accounts);\n\n ({ roleStore, dataStore, eventEmitter, oracleStore, oracle, wnt, wbtc, usdc } = fixture.contracts);\n ({ oracleSalt } = fixture.props);\n });\n\n it("inits", async () => {\n expect(await oracle.oracleStore()).to.eq(oracleStore.address);\n expect(await oracle.SALT()).to.eq(oracleSalt);\n });\n\n it("tamperPrices", async () => {\n const blockNumber = (await provider.getBlock()).number;\n const blockTimestamp = (await provider.getBlock()).timestamp;\n await dataStore.setUint(keys.MIN_ORACLE_SIGNERS, 2);\n const block = await provider.getBlock(blockNumber);\n\n let signerInfo = getSignerInfo([0, 1]);\n let minPrices = [1000, 1000]; // if some signers sign a same price\n let maxPrices = [1010, 1010]; // if some signers sign a same price\n let signatures = await signPrices({\n signers: [signer0, signer1],\n salt: oracleSalt,\n minOracleBlockNumber: blockNumber,\n maxOracleBlockNumber: blockNumber,\n oracleTimestamp: blockTimestamp,\n blockHash: block.hash,\n token: wnt.address,\n tokenOracleType: TOKEN_ORACLE_TYPES.DEFAULT,\n precision: 1,\n minPrices,\n maxPrices,\n });\n\n // attacker tamper the prices and indexes\n minPrices[1] = 2000\n maxPrices[1] = 2020\n let indexes = getCompactedPriceIndexes([0, 0]) // share the same index\n\n await oracle.setPrices(dataStore.address, eventEmitter.address, {\n priceFeedTokens: [],\n signerInfo,\n tokens: [wnt.address],\n compactedMinOracleBlockNumbers: [blockNumber],\n compactedMaxOracleBlockNumbers: [blockNumber],\n compactedOracleTimestamps: [blockTimestamp],\n compactedDecimals: getCompactedDecimals([1]),\n compactedMinPrices: getCompactedPrices(minPrices),\n compactedMinPricesIndexes: indexes,\n compactedMaxPrices: getCompactedPrices(maxPrices),\n compactedMaxPricesIndexes: indexes,\n signatures,\n });\n\n const decimals = 10\n expect((await oracle.getPrimaryPrice(wnt.address)).min).eq(1500 * decimals);\n expect((await oracle.getPrimaryPrice(wnt.address)).max).eq(1515 * decimals);\n });\n\n});\n```\n | medium |
```\nfunction recover(\n bytes32 hash,\n bytes32 r,\n bytes32 vs\n) internal pure returns (address) {\n (address recovered, RecoverError error) = tryRecover(hash, r, vs);\n _throwError(error);\n return recovered;\n}\n```\n | none |
```\nsettleFundingFees() = Short/LP need to pay Long 100\n\nmarginDepositedTotal = marginDepositedTotal + funding fee\nmarginDepositedTotal = y + (-100) = (y - 100)\n\nstableCollateralTotal = x + (-(-100)) = (x + 100)\n```\n | high |
```\nfunction getDepositInfo(address account) public view returns (DepositInfo memory info) {\n return deposits[account];\n}\n```\n | none |
```\n/\*\*\n \* @notice This is used by any router to decrease their available\n \* liquidity for a given asset.\n \* @param shares The amount of liquidity to remove for the router in shares\n \* @param assetId The address (or `address(0)` if native asset) of the\n \* asset you're removing liquidity for\n \* @param recipient The address that will receive the liquidity being removed\n \*/\nfunction removeLiquidity(\n uint256 shares,\n address assetId,\n address payable recipient\n) external override {\n // Sanity check: recipient is sensible\n require(recipient != address(0), "#RL:007");\n\n // Sanity check: nonzero shares\n require(shares > 0, "#RL:035");\n\n // Get stored router shares\n uint256 routerShares = issuedShares[msg.sender][assetId];\n\n // Get stored outstanding shares\n uint256 outstanding = outstandingShares[assetId];\n\n // Sanity check: owns enough shares\n require(routerShares >= shares, "#RL:018");\n\n // Convert shares to amount\n uint256 amount = getAmountFromIssuedShares(\n shares,\n outstanding,\n Asset.getOwnBalance(assetId)\n );\n\n // Update router issued shares\n // NOTE: unchecked due to require above\n unchecked {\n issuedShares[msg.sender][assetId] = routerShares - shares;\n }\n\n // Update the total shares for asset\n outstandingShares[assetId] = outstanding - shares;\n\n // Transfer from contract to specified recipient\n Asset.transferAsset(assetId, recipient, amount);\n\n // Emit event\n emit LiquidityRemoved(\n msg.sender,\n assetId,\n shares,\n amount,\n recipient\n );\n}\n```\n | medium |
```\n require(_poolWeights <= _calculateMaxVotePossible(_pool), "Max votes exceeded");\n```\n | high |
```\n (\n uint80 _latestRoundId,\n int256 _latestAnswer,\n /* uint256 _startedAt */,\n uint256 _latestTimestamp,\n /* uint80 _answeredInRound */\n ) = AggregatorV3Interface(_feed).latestRoundData();\n```\n | low |
```\nif (from.status == IStructs.StakeStatus.DELEGATED) {\n \_undelegateStake(\n from.poolId,\n staker,\n amount\n );\n}\n \nif (to.status == IStructs.StakeStatus.DELEGATED) {\n \_delegateStake(\n to.poolId,\n staker,\n amount\n );\n}\n```\n | low |
```\n Types.TokenRequest[] memory tokens = new Types.TokenRequest[](1); \n tokens[0] = Types.TokenRequest({token: inputToken, amount: amountIn});\n amountIn = amountIn / iterations;\n StrategyParams memory params = StrategyParams({ tokenIn: inputToken,\n tokenOut: outputToken, amountToSwap: amountIn, interval: interval, remitToOwner: remitToOwner\n });\n```\n | low |
```\n// 1. Only collect interest if it has been 30 mins\nuint256 timeSinceLastCollection = now.sub(previousCollection);\nif(timeSinceLastCollection > THIRTY\_MINUTES) {\n```\n | high |
```\nrequire(\n gasleft() >= _tx.gasLimit + FINALIZE_GAS_BUFFER,\n "OptimismPortal: insufficient gas to finalize withdrawal"\n);\n```\n | high |
```\nuint256[10] private \_gap;\n```\n | medium |
```\nfunction updateMarketingWallet(address newMarketingWallet) external onlyOwner {\n emit marketingWalletUpdated(newMarketingWallet, marketingWallet);\n marketingWallet = newMarketingWallet;\n}\n```\n | none |
```\nfunction drawNumberGrandPrize()\n external\n payable\n whenNotPaused\n onlyOwner\n requireState(DrawState.Closed)\n nonReentrant\n returns (bool)\n{\n if(msg.value > 0){\n _updateGrandPrizePool(_grandPrizePool.add(msg.value));\n }\n\n require(\n _grandPrizePool != 0 && address(this).balance.sub(_reserves) >= _grandPrizePool,\n "DCBW721: Not enough balance for grand prize"\n );\n\n bytes32 reqId = IRNG(_rngContract).request();\n\n _state = DrawState.Open;\n draws[_drawsToDate] = DrawData(\n _drawsToDate,\n uint32(block.timestamp), /* solium-disable-line */\n 0,\n 1,\n address(0),\n 0,\n _state,\n reqId\n );\n\n emit DrawInitiated(reqId);\n\n return true;\n}\n```\n | none |
```\n// Call the VendingMachine.\n// We could explictly encode the call to vending machine, but this would\n// involve manually parsing \_extraData and allocating variables.\n(bool success, bytes memory returnData) = address(vendingMachine).call(\n \_extraData\n);\nrequire(success, string(returnData));\n```\n | low |
```\nfunction _checkOnERC721Received(\n address from,\n address to,\n uint256 tokenId,\n bytes memory _data\n) private returns (bool) {\n if (to.isContract()) {\n try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\n return retval == IERC721Receiver.onERC721Received.selector;\n } catch (bytes memory reason) {\n if (reason.length == 0) {\n revert("ERC721: transfer to non ERC721Receiver implementer");\n } else {\n assembly {\n revert(add(32, reason), mload(reason))\n }\n }\n }\n } else {\n return true;\n }\n}\n```\n | none |
```\nfunction testVaultFeeIncorrectlySet() public {\n Dummy721 nft = new Dummy721();\n address tokenContract = address(nft);\n uint256 tokenId = uint256(1);\n address publicVault = _createPublicVault({\n strategist: strategistOne,\n delegate: strategistTwo,\n epochLength: 14 days\n });\n uint fee = PublicVault(publicVault).VAULT_FEE();\n console.log(fee)\n assert(fee == 5000); // 5000 is the value that was meant to be set\n}\n```\n | medium |
```\nfunction point\_mul(dst,src,s, mPtr) {\n // let mPtr := add(mload(0x40), state\_last\_mem)\n let state := mload(0x40)\n mstore(mPtr,mload(src))\n mstore(add(mPtr,0x20),mload(add(src,0x20)))\n mstore(add(mPtr,0x40),s)\n let l\_success := staticcall(sub(gas(), 2000),7,mPtr,0x60,dst,0x40)\n mstore(add(state, state\_success), and(l\_success,mload(add(state, state\_success))))\n}\n\n// dst <- dst + [s]src (Elliptic curve)\nfunction point\_acc\_mul(dst,src,s, mPtr) {\n let state := mload(0x40)\n mstore(mPtr,mload(src))\n mstore(add(mPtr,0x20),mload(add(src,0x20)))\n mstore(add(mPtr,0x40),s)\n let l\_success := staticcall(sub(gas(), 2000),7,mPtr,0x60,mPtr,0x40)\n mstore(add(mPtr,0x40),mload(dst))\n mstore(add(mPtr,0x60),mload(add(dst,0x20)))\n l\_success := and(l\_success, staticcall(sub(gas(), 2000),6,mPtr,0x80,dst, 0x40))\n mstore(add(state, state\_success), and(l\_success,mload(add(state, state\_success))))\n}\n```\n | high |
```\nfunction _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private {\n // if this is a sale and we're within the 24hr window, make total tax 25%\n bool isSale = recipient == uniswapV2Pair;\n bool isWithinTime = block.timestamp <= timeSalesTaxEnabled + 1 days;\n uint256 tmpPrevLiqFee = _liquidityFee;\n if(salesTaxEnabled && isSale && isWithinTime) {\n _liquidityFee = 23;\n }\n \n if(!takeFee)\n removeAllFee();\n \n if (_isExcluded[sender] && !_isExcluded[recipient]) {\n _transferFromExcluded(sender, recipient, amount);\n } else if (!_isExcluded[sender] && _isExcluded[recipient]) {\n _transferToExcluded(sender, recipient, amount);\n } else if (_isExcluded[sender] && _isExcluded[recipient]) {\n _transferBothExcluded(sender, recipient, amount);\n } else {\n _transferStandard(sender, recipient, amount);\n }\n \n if(!takeFee)\n restoreAllFee();\n\n if(salesTaxEnabled) {\n _liquidityFee = tmpPrevLiqFee;\n }\n\n // if we're past the 24 hours, disable the sales tax\n if(salesTaxEnabled && !isWithinTime) {\n toggleSalesTax(false);\n }\n}\n```\n | none |
```\nfunction _scaleAmountByPercentage(uint256 amount, uint256 scaledPercent)\n internal\n pure\n returns (uint256 scaledAmount)\n{\n // use assembly to bypass checking for overflow & division by 0\n // scaledPercent has been validated to be < PERCENTAGE_SCALE)\n // & PERCENTAGE_SCALE will never be 0\n // pernicious ERC20s may cause overflow, but results do not affect ETH & other ERC20 balances\n assembly {\n /* eg (100 * 2*1e4) / (1e6) */\n scaledAmount := div(mul(amount, scaledPercent), PERCENTAGE_SCALE)\n }\n}\n```\n | none |
```\n/\*\*\n \* Calculate x + y. Revert on overflow.\n \*\n \* @param x signed 64.64-bit fixed point number\n \* @param y signed 64.64-bit fixed point number\n \* @return signed 64.64-bit fixed point number\n \*/\nfunction add (int128 x, int128 y) internal pure returns (int128) {\n int256 result = int256(x) + y;\n require (result >= MIN\_64x64 && result <= MAX\_64x64);\n return int128 (result);\n}\n```\n | medium |
```\nfunction _validateSenderAndPaymaster(bytes calldata initCode, address sender, bytes calldata paymasterAndData) external view {\n if (initCode.length == 0 && sender.code.length == 0) {\n // it would revert anyway. but give a meaningful message\n revert("AA20 account not deployed");\n }\n if (paymasterAndData.length >= 20) {\n address paymaster = address(bytes20(paymasterAndData[0 : 20]));\n if (paymaster.code.length == 0) {\n // it would revert anyway. but give a meaningful message\n revert("AA30 paymaster not deployed");\n }\n }\n // always revert\n revert("");\n}\n```\n | none |
```\n uint256 strTokenAmt = _doBorrow(param.borrowToken, param.borrowAmount);\n\n // 3. Swap borrowed token to strategy token\n IERC20Upgradeable swapToken = ISoftVault(strategy.vault).uToken();\n // swapData.fromAmount = strTokenAmt;\n PSwapLib.megaSwap(augustusSwapper, tokenTransferProxy, swapData);\n strTokenAmt = swapToken.balanceOf(address(this)) - strTokenAmt; <- @audit-issue will always revert on swap\n```\n | high |
```\n function test_badDebtLiquidationAnte() public {\n\n // malicious user borrows at max leverage + some safety margin\n uint256 margin0 = 1e18;\n uint256 borrows0 = 100e18;\n\n deal(address(asset0), address(account), margin0);\n\n bytes memory data = abi.encode(Action.BORROW, borrows0, 0);\n account.modify(this, data, (1 << 32));\n\n // borrow increased by 50%\n _setInterest(lender0, 15000);\n\n emit log_named_uint("User borrow:", lender0.borrowBalance(address(account)));\n emit log_named_uint("User assets:", asset0.balanceOf(address(account)));\n\n // warn account\n account.warn((1 << 32));\n\n // skip warning time\n skip(LIQUIDATION_GRACE_PERIOD);\n lender0.accrueInterest();\n\n // liquidation reverts because it requires asset the account doesn't have to swap\n vm.expectRevert();\n account.liquidate(this, bytes(""), 1, (1 << 32));\n\n // liquidate with max strain to avoid revert when trying to swap assets account doesn't have\n account.liquidate(this, bytes(""), type(uint256).max, (1 << 32));\n\n emit log_named_uint("Liquidated User borrow:", lender0.borrowBalance(address(account)));\n emit log_named_uint("Liquidated User assets:", asset0.balanceOf(address(account)));\n emit log_named_uint("Liquidated User ante:", address(account).balance);\n }\n```\n | medium |
```\nPolicyHolder storage holder = policyHolders[claimer];\n\nepochAmounts[holder.endEpochNumber] = epochAmounts[holder.endEpochNumber].sub(holder.coverTokens);\ntotalLiquidity = totalLiquidity.sub(claimAmount);\n\ndaiToken.transfer(claimer, claimAmount);\n \ndelete policyHolders[claimer];\npolicyRegistry.removePolicy(claimer);\n```\n | high |
```\nit('adiabatic fee', async () => {\n function setupOracle(price: string, timestamp : number, nextTimestamp : number) {\n const oracleVersion = {\n price: parse6decimal(price),\n timestamp: timestamp,\n valid: true,\n }\n oracle.at.whenCalledWith(oracleVersion.timestamp).returns(oracleVersion)\n oracle.status.returns([oracleVersion, nextTimestamp])\n oracle.request.returns()\n }\n\n async function showInfo() {\n await market.settle(user.address);\n await market.settle(userB.address);\n await market.settle(userC.address);\n var sum : BigNumber = BigNumber.from('0');\n var info = await market.locals(user.address);\n console.log("user collateral = " + info.collateral);\n sum = sum.add(info.collateral);\n var info = await market.locals(userB.address);\n sum = sum.add(info.collateral);\n console.log("userB collateral = " + info.collateral);\n var info = await market.locals(userC.address);\n sum = sum.add(info.collateral);\n }\n\n async function showVer(ver : number) {\n var v = await market.versions(ver);\n console.log("ver" + ver + ": makerValue=" + v.makerValue + " longValue=" + v.longValue + \n " makerPosFee=" + v.makerPosFee + " makerNegFee=" + v.makerNegFee +\n " takerPosFee=" + v.takerPosFee + " takerNegFee=" + v.takerNegFee\n );\n }\n\n const riskParameter = { // rest of code(await market.riskParameter()) }\n const riskParameterMakerFee = { // rest of coderiskParameter.makerFee }\n riskParameterMakerFee.linearFee = parse6decimal('0.00')\n riskParameterMakerFee.proportionalFee = parse6decimal('0.00')\n riskParameterMakerFee.adiabaticFee = parse6decimal('0.01')\n riskParameterMakerFee.scale = parse6decimal('50.0')\n riskParameter.makerFee = riskParameterMakerFee\n const riskParameterTakerFee = { // rest of coderiskParameter.takerFee }\n riskParameterTakerFee.linearFee = parse6decimal('0.00')\n riskParameterTakerFee.proportionalFee = parse6decimal('0.00')\n riskParameterTakerFee.adiabaticFee = parse6decimal('0.01')\n riskParameterTakerFee.scale = parse6decimal('50.0')\n riskParameter.takerFee = riskParameterTakerFee\n await market.connect(owner).updateRiskParameter(riskParameter)\n\n marketParameter = {\n fundingFee: parse6decimal('0.0'),\n interestFee: parse6decimal('0.0'),\n oracleFee: parse6decimal('0.0'),\n riskFee: parse6decimal('0.0'),\n positionFee: parse6decimal('0.0'),\n maxPendingGlobal: 5,\n maxPendingLocal: 3,\n settlementFee: 0,\n makerCloseAlways: false,\n takerCloseAlways: false,\n closed: false,\n settle: false,\n }\n await market.connect(owner).updateParameter(beneficiary.address, coordinator.address, marketParameter)\n\n var time = TIMESTAMP;\n\n setupOracle('1', time, time + 100);\n await market.connect(user)\n ['update(address,uint256,uint256,uint256,int256,bool)'](user.address, POSITION, 0, 0, COLLATERAL, false);\n await showInfo()\n await showVer(time)\n\n time += 100;\n setupOracle('1', time, time + 100);\n await market.connect(userB)\n ['update(address,uint256,uint256,uint256,int256,bool)'](userB.address, POSITION, 0, 0, COLLATERAL, false);\n await showInfo()\n await showVer(time)\n\n time += 100;\n setupOracle('1', time, time + 100);\n await showInfo()\n await showVer(time)\n\n time += 100;\n setupOracle('2', time, time + 100);\n await market.connect(userB)\n ['update(address,uint256,uint256,uint256,int256,bool)'](userB.address, 0, 0, 0, 0, false);\n await showInfo()\n await showVer(time)\n\n time += 100;\n setupOracle('2', time, time + 100);\n await market.connect(user)\n ['update(address,uint256,uint256,uint256,int256,bool)'](user.address, 0, 0, 0, 0, false);\n await showInfo()\n await showVer(time)\n\n time += 100;\n setupOracle('0.5', time, time + 100);\n await showInfo()\n await showVer(time)\n})\n```\n | medium |
```\nfunction updateCommitment(\n uint256 _commitmentId,\n Commitment calldata _commitment\n) public commitmentLender(_commitmentId) { <- @audit-info checks that lender is msg.sender\n require(\n _commitment.principalTokenAddress ==\n commitments[_commitmentId].principalTokenAddress,\n "Principal token address cannot be updated."\n );\n require(\n _commitment.marketId == commitments[_commitmentId].marketId,\n "Market Id cannot be updated."\n );\n\n commitments[_commitmentId] = _commitment; <- @audit-issue never checks _commitment.lender\n\n validateCommitment(commitments[_commitmentId]);\n```\n | high |
```\n uint256 tokenReserve = _getBalance(token);\n uint256 tokenCollateral = IInsurancePool(insurancePool).getCollateral(token);\n```\n | medium |
```\nfunction setFeeOracle(address _feeOracle) external onlyRole(TOKEN_MANAGER) {\n feeOracle = _feeOracle;\n}\n```\n | none |
```\n ohmMinted -= ohmReceived > ohmMinted ? ohmMinted : ohmReceived;\n ohmRemoved += ohmReceived > ohmMinted ? ohmReceived - ohmMinted : 0;\n```\n | medium |
```\nfunction sub(\n uint256 a,\n uint256 b,\n string memory errorMessage\n) internal pure returns (uint256) {\n unchecked {\n require(b <= a, errorMessage);\n return a - b;\n }\n}\n```\n | none |
```\nfunction includeAsset (address \_numeraire, address \_nAssim, address \_reserve, address \_rAssim, uint256 \_weight) public onlyOwner {\n shell.includeAsset(\_numeraire, \_nAssim, \_reserve, \_rAssim, \_weight);\n}\n```\n | high |
```\n ICommonStruct.TokenAmount[] memory bribeTokens = _sdtBlackHole.pullSdStakingBribes(\n processor,\n _processorRewardsPercentage\n );\n\n uint256 rewardAmount = _gaugeAsset.reward_count();\n\n ICommonStruct.TokenAmount[] memory tokenAmounts = new ICommonStruct.TokenAmount[](\n rewardAmount + bribeTokens.length\n );\n\n uint256 counter;\n address _processor = processor;\n for (uint256 j; j < rewardAmount; ) {\n IERC20 token = _gaugeAsset.reward_tokens(j);\n uint256 balance = token.balanceOf(address(this));\n if (balance != 0) {\n uint256 fullBalance = balance;\n\n // rest of code\n\n token.transfer(sdtRewardsReceiver, balance);\n\n **@audit token and amount added from reward_tokens pulled directly from gauge**\n\n tokenAmounts[counter++] = ICommonStruct.TokenAmount({token: token, amount: balance});\n }\n\n // rest of code\n\n }\n\n for (uint256 j; j < bribeTokens.length; ) {\n IERC20 token = bribeTokens[j].token;\n uint256 amount = bribeTokens[j].amount;\n\n **@audit token and amount added directly with no check for duplicate token**\n\n if (amount != 0) {\n tokenAmounts[counter++] = ICommonStruct.TokenAmount({token: token, amount: amount});\n\n // rest of code\n\n }\n```\n | high |
```\n function createDeposit(\n DataStore dataStore,\n EventEmitter eventEmitter,\n DepositVault depositVault,\n address account,\n CreateDepositParams memory params\n ) external returns (bytes32) {\n Market.Props memory market = MarketUtils.getEnabledMarket(dataStore, params.market);\n\n uint256 initialLongTokenAmount = depositVault.recordTransferIn(params.initialLongToken);\n uint256 initialShortTokenAmount = depositVault.recordTransferIn(params.initialShortToken);\n\n address wnt = TokenUtils.wnt(dataStore);\n\n if (market.longToken == wnt) {\n initialLongTokenAmount -= params.executionFee;\n } else if (market.shortToken == wnt) {\n initialShortTokenAmount -= params.executionFee;\n```\n | high |
```\nfunction updateRewardsMultiplier() external {\n if (!_multiplier[msg.sender]) {\n _multiplier[msg.sender] = true;\n }\n dividendTracker.setBalance(msg.sender, getMultiplier(msg.sender));\n}\n```\n | none |
```\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 |
```\nif (\_isPurchased[delegationId]) {\n address holder = delegation.holder;\n \_totalDelegated[holder] += delegation.amount;\n if (\_totalDelegated[holder] >= \_purchased[holder]) {\n purchasedToUnlocked(holder);\n }\n}\n```\n | high |
```\n// Sanity check: fee <= amount. Allow `=` in case of only wanting to execute\n// 0-value crosschain tx, so only providing the fee amount\nrequire(relayerFee <= txData.amount, "#F:023");\n```\n | high |
```\n// ROUND\_HALF\_UP rule helper. 0.5 ≈ 1, 0.4 ≈ 0, -0.5 ≈ -1, -0.4 ≈ 0\nfunction roundHalfUp(int256 x, int256 y) internal pure returns (int256) {\n require(y > 0, "roundHalfUp only supports y > 0");\n if (x >= 0) {\n return add(x, y / 2);\n }\n return sub(x, y / 2);\n}\n```\n | low |
```\nuint256 private constant ONE\_WAD\_U = 10\*\*18;\n```\n | low |
```\nFile: LiquidationModule.sol\n function liquidate(\n uint256 tokenID,\n bytes[] calldata priceUpdateData\n ) external payable whenNotPaused updatePythPrice(vault, msg.sender, priceUpdateData) {\n liquidate(tokenID);\n }\n\n /// @notice Function to liquidate a position.\n /// @dev One could directly call this method instead of `liquidate(uint256, bytes[])` if they don't want to update the Pyth price.\n /// @param tokenId The token ID of the leverage position.\n function liquidate(uint256 tokenId) public nonReentrant whenNotPaused liquidationInvariantChecks(vault, tokenId) {\n FlatcoinStructs.Position memory position = vault.getPosition(tokenId);\n```\n | medium |
```\nfunction removeLimits() external onlyOwner returns (bool) {\n limitsInEffect = false;\n return true;\n}\n```\n | none |
```\n } else {\n uint256 netRepayLimit = _actionInfo.collateralValue\n .preciseMul(liquidationThresholdRaw.mul(10 ** 14))\n .preciseMul(PreciseUnitMath.preciseUnit().sub(execution.unutilizedLeveragePercentage));\n\n return _actionInfo.collateralBalance\n .preciseMul(netRepayLimit.sub(_actionInfo.borrowValue))\n .preciseDiv(netRepayLimit);\n }\n```\n | high |
```\nuint256 publicInput = uint256(\n keccak256(\n abi.encode(\n shnarf,\n \_finalizationData.parentStateRootHash,\n \_finalizationData.lastFinalizedTimestamp,\n \_finalizationData.finalBlockNumber,\n \_finalizationData.finalTimestamp,\n \_finalizationData.l1RollingHash,\n \_finalizationData.l1RollingHashMessageNumber,\n keccak256(abi.encodePacked(\_finalizationData.l2MerkleRoots))\n )\n```\n | high |
```\nfunction \_transferETH(address \_recipient, uint256 \_amount) private {\n```\n | high |
```\nfunction excludeFromReward(address account) public onlyOwner {\n require(!_isExcluded[account], "Account is already excluded");\n if (_rOwned[account] > 0) {\n _tOwned[account] = tokenFromReflection(_rOwned[account]);\n }\n _isExcluded[account] = true;\n _excluded.push(account);\n}\n```\n | none |
```\nuint256 arb = withdrawalPoolById(DATASTORE, poolId)\n .calculateSwap(0, 1, cumBal);\n```\n | low |
```\nfunction _getRequiredPrefund(MemoryUserOp memory mUserOp) internal pure returns (uint256 requiredPrefund) {\nunchecked {\n //when using a Paymaster, the verificationGasLimit is used also to as a limit for the postOp call.\n // our security model might call postOp eventually twice\n uint256 mul = mUserOp.paymaster != address(0) ? 3 : 1;\n uint256 requiredGas = mUserOp.callGasLimit + mUserOp.verificationGasLimit * mul + mUserOp.preVerificationGas;\n\n requiredPrefund = requiredGas * mUserOp.maxFeePerGas;\n}\n}\n```\n | none |
```\nfunction initializeInvestorStateDefault(\n address[] memory addresses\n ) external onlyRole(CONFIGURER_ROLE) {\n _initializeInvestorState(\n addresses,\n defaultMintLimit,\n defaultRedemptionLimit,\n defaultMintLimitDuration,\n defaultRedemptionLimitDuration\n );\n}\n\nfunction _initializeInvestorState(\n address[] memory addresses,\n uint256 mintLimit,\n uint256 redemptionLimit,\n uint256 mintLimitDuration,\n uint256 redemptionLimitDuration\n ) internal {\n uint256 investorId = ++investorIdCounter;\n\n // @audit this `for` loop can by bypassed by calling\n // `initializeInvestorStateDefault` with an empty array\n for (uint256 i = 0; i < addresses.length; ++i) {\n // Safety check to ensure the address is not already associated with an investor\n // before associating it with a new investor\n if (addressToInvestorId[addresses[i]] != 0) {\n revert AddressAlreadyAssociated();\n }\n _setAddressToInvestorId(addresses[i], investorId);\n }\n\n investorIdToMintState[investorId] = RateLimit({\n currentAmount: 0,\n limit: mintLimit,\n lastResetTime: block.timestamp,\n limitDuration: mintLimitDuration\n });\n investorIdToRedemptionState[investorId] = RateLimit({\n currentAmount: 0,\n limit: redemptionLimit,\n lastResetTime: block.timestamp,\n limitDuration: redemptionLimitDuration\n });\n}\n```\n | low |
```\nfunction excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {\n _isExcludedMaxTransactionAmount[updAds] = isEx;\n}\n```\n | none |
```\n receive() external payable {\n emit EthReceived(msg.sender, msg.value);\n\n```\n | none |
```\n {\n uint88 currentShortCollateral = currentShort.collateral;\n uint88 currentShortErcDebt = currentShort.ercDebt;\n collateral += currentShortCollateral;\n ercDebt += currentShortErcDebt;\n yield += currentShortCollateral.mul(currentShort.zethYieldRate);\n ercDebtSocialized += currentShortErcDebt.mul(currentShort.ercDebtRate);\n }\n```\n | medium |
```\nfunction sub(uint256 a, uint256 b) internal pure returns (uint256) {\n return sub(a, b, "SafeMath: subtraction overflow");\n}\n```\n | none |
```\nfunction safeTransfer(\n IERC20 token,\n address to,\n uint256 value\n) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n}\n```\n | none |
```\nfunction distributeLiquidatedFunds(uint256 agentID, uint256 amount) external {\n if (!liquidated[agentID]) revert Unauthorized();\n\n // transfer the assets into the pool\n GetRoute.wFIL(router).transferFrom(msg.sender, address(this), amount);\n \_writeOffPools(agentID, amount);\n}\n```\n | medium |
```\nfunction _burn(address account, uint256 value) internal override {\n super._burn(account, value);\n\n magnifiedDividendCorrections[account] = magnifiedDividendCorrections[account]\n .add((magnifiedDividendPerShare.mul(value)).toInt256Safe());\n}\n```\n | none |
```\nfunction _depositAsset(uint256 amount) private {\n netAssetDeposits += amount;\n \n IERC20(assetToken).approve(address(vault), amount);\n vault.deposit(assetToken, amount);\n}\n```\n | medium |
```\nfunction setValidatorAddress(uint128 validatorId, address newAddress) external whenNotPaused {\n // // rest of code\n v.stakings[newAddress].shares += v.stakings[msg.sender].shares;\n v.stakings[newAddress].staked += v.stakings[msg.sender].staked;\n delete v.stakings[msg.sender];\n // // rest of code\n}\n```\n | medium |
```\nconstructor() {\n _status = _NOT_ENTERED;\n}\n```\n | none |
```\nfunction _compensate(address payable beneficiary, uint256 amount) internal {\n require(beneficiary != address(0), "AA90 invalid beneficiary");\n (bool success,) = beneficiary.call{value : amount}("");\n require(success, "AA91 failed send to beneficiary");\n}\n```\n | none |
```\nliqCumL + uint160(((liqCumR - liqCumL) * delta) / denom)\n```\n | medium |
```\n address[] memory targets = new address[](UNDERLYING_IS_ETH ? 2 : 1);\n bytes[] memory callData = new bytes[](UNDERLYING_IS_ETH ? 2 : 1);\n targets[0] = LENDING_POOL;\n callData[0] = abi.encodeWithSelector(\n ILendingPool.withdraw.selector, underlyingToken, withdrawAmount, address(NOTIONAL)\n );\n\n if (UNDERLYING_IS_ETH) {\n // Aave V3 returns WETH instead of native ETH so we have to unwrap it here\n targets[1] = address(Deployments.WETH);\n callData[1] = abi.encodeWithSelector(WETH9.withdraw.selector, withdrawAmount);\n }\n\n data = new RedeemData[](1);\n // Tokens with less than or equal to 8 decimals sometimes have off by 1 issues when depositing\n // into Aave V3. Aave returns one unit less than has been deposited. This adjustment is applied\n // to ensure that this unit of token is credited back to prime cash holders appropriately.\n uint8 rebasingTokenBalanceAdjustment = UNDERLYING_DECIMALS <= 8 ? 1 : 0;\n data[0] = RedeemData(\n targets, callData, withdrawAmount, ASSET_TOKEN, rebasingTokenBalanceAdjustment\n );\n```\n | medium |
```\nfunction _transferStandard(address sender, address recipient, uint256 tAmount) private {\n (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);\n _rOwned[sender] = _rOwned[sender].sub(rAmount);\n _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);\n _takeTeam(tTeam);\n _reflectFee(rFee, tFee);\n emit Transfer(sender, recipient, tTransferAmount);\n}\n```\n | none |
```\nfunction sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = sqrt(a);\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\n }\n}\n```\n | none |
```\nfunction trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b > a) return (false, 0);\n return (true, a - b);\n }\n}\n```\n | none |
```\nfunction functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, "Address: low-level call failed");\n}\n```\n | none |
```\nfunction mod(uint256 a, uint256 b) internal pure returns (uint256) {\n return mod(a, b, "SafeMath: modulo by zero");\n}\n```\n | none |
```\nfunction exemptFromLimits(\n address updAds,\n bool isEx\n) public onlyOwner {\n transferLimitExempt[updAds] = isEx;\n emit ExcludeFromLimits(updAds, isEx);\n}\n```\n | none |
```\nfunction changeHatToggle(uint256 _hatId, address _newToggle) external {\n if (_newToggle == address(0)) revert ZeroAddress();\n\n _checkAdmin(_hatId);\n Hat storage hat = _hats[_hatId];\n\n if (!_isMutable(hat)) {\n revert Immutable();\n }\n\n hat.toggle = _newToggle;\n\n emit HatToggleChanged(_hatId, _newToggle);\n}\n```\n | medium |
```\n IERC20(asset).safeTransferFrom(msg.sender, address(this), amount);\n (address approveTarget, address swapTarget, bytes memory data) = abi\n .decode(param, (address, address, bytes));\n // if usdt\n IERC20(asset).approve(approveTarget, 0);\n IERC20(asset).approve(approveTarget, amount);\n (bool success, ) = swapTarget.call(data);\n if (success == false) {\n assembly {\n let ptr := mload(0x40)\n let size := returndatasize()\n returndatacopy(ptr, 0, size)\n revert(ptr, size)\n }\n }\n```\n | high |
```\n(bool sent, ) = address(operatorAddress).call{value: msg.value}("");\nif (!sent) revert Unauthorized();\n```\n | low |
```\n// Findings are labeled with '<= FOUND'\n// File: dodo-gassaving-pool/contracts/GasSavingPool/impl/GSPFunding.sol\n function buyShares(address to)\n // rest of code\n // case 1. initial supply\n // The shares will be minted to user\n shares = quoteBalance < DecimalMath.mulFloor(baseBalance, _I_) // <= FOUND\n ? DecimalMath.divFloor(quoteBalance, _I_)\n : baseBalance; // @audit-info mint shares based on min balance(base, quote)\n // The target will be updated\n _BASE_TARGET_ = uint112(shares);\n // rest of code\n }\n```\n | medium |
```\nfunction rebind(address token, uint balance, uint denorm)\n public\n \_logs\_\n \_lock\_\n{\n\n require(msg.sender == \_controller, "ERR\_NOT\_CONTROLLER");\n require(\_records[token].bound, "ERR\_NOT\_BOUND");\n require(!\_finalized, "ERR\_IS\_FINALIZED");\n\n require(denorm >= MIN\_WEIGHT, "ERR\_MIN\_WEIGHT");\n require(denorm <= MAX\_WEIGHT, "ERR\_MAX\_WEIGHT");\n require(balance >= MIN\_BALANCE, "ERR\_MIN\_BALANCE");\n```\n | low |
```\nit('exchange rate manipulation', async () => {\n const smallDeposit = utils.parseEther('1')\n const smallestDeposit = utils.parseEther('0.000000000000000001')\n\n // make a deposit with the attacker. Deposit 1 Wei to mint 1 Wei of shares\n await vault.connect(user).deposit(smallestDeposit, user.address)\n await updateOracle();\n await vault.sync()\n\n console.log(await vault.totalSupply());\n\n // donating assets to Vault\n await dsu.connect(user).transfer(vault.address, utils.parseEther('1'))\n\n console.log(await vault.totalAssets());\n\n // make a deposit with the victim. Due to rounding the victim will end up with 0 shares\n await updateOracle();\n await vault.sync()\n await vault.connect(user2).deposit(smallDeposit, user2.address)\n await updateOracle();\n await vault.sync()\n\n console.log(await vault.totalAssets());\n console.log(await vault.totalSupply());\n // the amount of shares the victim receives is rounded down to 0\n console.log(await vault.balanceOf(user2.address));\n\n /*\n at this point there are 2000000000000000001 Wei of assets in the Vault and only 1 Wei of shares\n which is owned by the attacker.\n This means the attacker has stolen all funds from the victim.\n */\n })\n```\n | medium |
```\n/// @title Ethereum Staking Contract\n/// @author Kiln\n/// @notice You can use this contract to store validator keys and have users fund them and trigger deposits.\ncontract StakingContract {\n using StakingContractStorageLib for bytes32;\n```\n | low |
```\n function balanceOf(address _wearer, uint256 _hatId)\n public\n view\n override(ERC1155, IHats)\n returns (uint256 balance)\n {\n Hat storage hat = _hats[_hatId];\n\n balance = 0;\n\n if (_isActive(hat, _hatId) && _isEligible(_wearer, hat, _hatId)) {\n balance = super.balanceOf(_wearer, _hatId);\n }\n }\n```\n | medium |
```\nif (msg.sender != holder) {\n require(msg.sender == operator, "invalid request");\n}\n```\n | medium |
```\nfunction decimals() public view returns (uint8) {\n return _decimals;\n}\n```\n | none |
```\nGEM.newProposal(proposal.CONTROLLER, 2, proposal.NAME, 4 weeks);\n```\n | high |
```\nfunction investDAI(uint256 \_tokensAmount, address \_policyBookAddr) external override {\n```\n | high |
```\nfunction excludeFromFees(address account, bool excluded) public onlyOwner {\n _isExcludedFromFees[account] = excluded;\n emit ExcludeFromFees(account, excluded);\n}\n```\n | none |