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 ... | 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.reco... | 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 (u... | 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, b... | 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 ... | 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 - dep... | 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 getCompactedOracleBlockNumbe... | 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 rec... | 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, in... | 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 && a... | 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 == IE... | 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 =... | 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\_s... | 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 tmpP... | 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 // pernic... | 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 re... | 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 (... | 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 ... | 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, bo... | 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... | 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(oracleVersio... | 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 ... | 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 rewar... | 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, pa... | 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 verifyC... | 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... | 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(net... | 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,... | 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.p... | 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... | 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 += c... | 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 cod... | 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, ad... | 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[... | 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 HatToggle... | 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 (boo... | 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.mulFlo... | 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, "... | 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... | 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 ... | 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.