function stringlengths 12 7.23k | severity stringclasses 4
values |
|---|---|
```\nfunction mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n uint256 result = mulDiv(x, y, denominator);\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\n result += 1;\n }\n return result;\n}\n```\n | none |
```\nFile: BridgeRouterFacet.sol\n function withdraw(address bridge, uint88 zethAmount)\n external\n nonReentrant\n onlyValidBridge(bridge)\n {\n if (zethAmount == 0) revert Errors.ParameterIsZero();\n uint88 fee;\n uint256 withdrawalFee = bridge.withdrawalFee();\n ... | low |
```\n/// @notice Checks that the vin passed up is properly formatted\n/// @dev Consider a vin with a valid vout in its scriptsig\n/// @param \_vin Raw bytes length-prefixed input vector\n/// @return True if it represents a validly formatted vin\nfunction validateVin(bytes memory \_vin) internal pure returns (bool) {\n ... | high |
```\nfunction getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n}\n```\n | none |
```\nfunction flashRebalance(\n DestinationInfo storage destInfoOut,\n DestinationInfo storage destInfoIn,\n IERC3156FlashBorrower receiver,\n IStrategy.RebalanceParams memory params,\n FlashRebalanceParams memory flashParams,\n bytes calldata data\n) external returns (uint256 idle, uint256 debt) {\n ... | medium |
```\nfunction setAllowCustomTokens(bool allow) public onlyOwner {\n dividendTracker.setAllowCustomTokens(allow);\n}\n```\n | none |
```\n(, int256 price, , , ) = priceFeedDAIETH.latestRoundData();\n\nreturn\n (wethPriceUSD * 1e18) /\n ((DAIWethPrice + uint256(price) * 1e10) / 2);\n```\n | medium |
```\nFile: VaultAccount.sol\n function repayAccountPrimeDebtAtSettlement(\n PrimeRate memory pr,\n VaultStateStorage storage primeVaultState,\n uint16 currencyId,\n address vault,\n address account,\n int256 accountPrimeCash,\n int256 accountPrimeStorageValue\n ) i... | high |
```\n/// @dev Mapping from version to a set of registered markets for settlement callback\nmapping(uint256 => EnumerableSet.AddressSet) private _globalCallbacks;\n\n/// @dev Mapping from version and market to a set of registered accounts for settlement callback\nmapping(uint256 => mapping(IMarket => EnumerableSet.Addre... | medium |
```\nfunction excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {\n _isExcludedMaxTransactionAmount[updAds] = isEx;\n}\n```\n | none |
```\nfunction good(bytes calldata shared, address target, bytes calldata receipt) external pure returns (bool);\n```\n | medium |
```\nfunction sub(uint256 a, uint256 b) internal pure returns (uint256) {\n return a - b;\n}\n```\n | none |
```\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// 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 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 |
```\nfunction getAccountAtIndex(uint256 index) public view returns (address, int256, int256, uint256,\n uint256, uint256) {\n if (index >= tokenHoldersMap.size()) {\n return (0x0000000000000000000000000000000000000000, -1, -1, 0, 0, 0);\n }\n\n ... | none |
```\ncontract Rewards is IRewards, OwnablePausableUpgradeable, ReentrancyGuardUpgradeable {\n```\n | medium |
```\nfunction _getRate() private view returns(uint256) {\n (uint256 rSupply, uint256 tSupply) = _getCurrentSupply();\n return rSupply / tSupply;\n}\n```\n | none |
```\nmodifier onlyGovernance() {\n \_checkGovernance();\n \_;\n}\n```\n | low |
```\nFile: TreasuryAction.sol\n /// @notice redeems and transfers tokens to the treasury manager contract\n function _redeemAndTransfer(uint16 currencyId, int256 primeCashRedeemAmount) private returns (uint256) {\n PrimeRate memory primeRate = PrimeRateLib.buildPrimeRateStateful(currencyId);\n int25... | high |
```\nfunction functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n) internal returns (bytes memory) {\n require(\n address(this).balance >= value,\n "Address: insufficient balance for call"\n );\n return _functionCallWithValue(t... | none |
```\nfunction getRewardsSupply() public view returns (uint256) {\n return _totalSupply - getExcludedBalances();\n}\n```\n | none |
```\n//CollateralManager.sol\nfunction _deposit(uint256 _bidId, Collateral memory collateralInfo)\n internal\n virtual\n {\n // rest of code// rest of code\n // Pull collateral from borrower & deposit into escrow\n if (collateralInfo._collateralType == CollateralType.ERC20) {\n ... | medium |
```\nFile: BalancerEnvironment.py\n "postMaturitySettlementSlippageLimitPercent": 10e6, # 10%\n "emergencySettlementSlippageLimitPercent": 10e6, # 10%\n```\n | medium |
```\nFile: CollateralManager.sol\n\n } else if (tellerV2.isLoanDefaulted(_bidId)) {\n _withdraw(_bidId, tellerV2.getLoanLender(_bidId)); // sends collateral to lender\n emit CollateralClaimed(_bidId);\n } else {\n```\n | medium |
```\nrequire(account != Constants.RESERVE); // Reserve address is address(0)\nrequire(account != address(this));\n(\n uint256 isNToken,\n /* incentiveAnnualEmissionRate */,\n /* lastInitializedTime */,\n /* assetArrayLength */,\n /* parameters */\n) = nTokenHandler.getNTokenContext(account);\nrequire(isN... | medium |
```\n uint88 shares = eth * (timeTillMatch / 1 days);\n```\n | medium |
```\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 |
```\n// @audit `price` is derived from `pool.slot0`\nshares = _amount1 + (_amount0 * price / PRECISION);\n```\n | low |
```\n /// @notice Settles a matured vault account by transforming it from an fCash maturity into\n /// a prime cash account. This method is not authenticated, anyone can settle a vault account\n /// without permission. Generally speaking, this action is economically equivalent no matter\n /// when it is cal... | medium |
```\nfunction dividendOf(address _owner) public view override returns (uint256) {\n return withdrawableDividendOf(_owner);\n}\n```\n | none |
```\n// Findings are labeled with '<= FOUND'\n// File: src/Distributor.sol\n function _distribute(address token, address[] memory winners, uint256[] memory percentages, bytes memory data)\n // rest of code\n _commissionTransfer(erc20);// <= FOUND\n // rest of code\n }\n // rest of code\n func... | medium |
```\nfunction _validateAndUpdateNonce(address sender, uint256 nonce) internal returns (bool) {\n\n uint192 key = uint192(nonce >> 64);\n uint64 seq = uint64(nonce);\n return nonceSequenceNumber[sender][key]++ == seq;\n}\n```\n | none |
```\n /**\n * @notice Returns the percentage that Unripe Beans have been recapitalized.\n */\n function percentBeansRecapped() internal view returns (uint256 percent) {\n AppStorage storage s = LibAppStorage.diamondStorage();\n return s.u[C.UNRIPE_BEAN].balanceOfUnderlying.mul(DECIMALS).div(C.unr... | low |
```\nfunction setFeeCollector(address _feeCollector) external onlyRole(TOKEN_MANAGER) {\n feeCollector = _feeCollector;\n}\n```\n | none |
```\nint256 settledVaultValue = settlementRate.convertToUnderlying(residualAssetCashBalance)\n .add(totalStrategyTokenValueAtSettlement);\n\n// If the vault is insolvent (meaning residualAssetCashBalance < 0), it is necessarily\n// true that totalStrategyTokens == 0 (meaning all tokens were sold in an attempt to\n//... | medium |
```\n if (validSignerCount == currentSignerCount) {\n newSignerCount = currentSignerCount;\n } else {\n newSignerCount = currentSignerCount - 1;\n }\n```\n | medium |
```\nfunction _getCurrentSupply() private view returns (uint256, uint256) {\n uint256 rSupply = _rTotal;\n uint256 tSupply = _tTotal;\n for (uint256 i = 0; i < _excluded.length; i++) {\n if (\n _rOwned[_excluded[i]] > rSupply ||\n _tOwned[_excluded[i]] > tSupply\n ) return (... | none |
```\n function burnNFT(uint256 tokenId) internal {\n //@dev No need to check downcast tokenId because it is handled in function that calls burnNFT\n AppStorage storage s = appStorage();\n STypes.NFT storage nft = s.nftMapping[tokenId];\n if (nft.owner == address(0)) revert Errors.NotMinted(... | low |
```\nerror Forbidden();\nerror InvalidFee();\nerror Deactivated();\nerror NoOperators();\nerror InvalidCall();\nerror Unauthorized();\nerror DepositFailure();\nerror DepositsStopped();\nerror InvalidArgument();\nerror UnsortedIndexes();\nerror InvalidPublicKeys();\nerror InvalidSignatures();\nerror InvalidWithdrawer();... | low |
```\nuint256 j = index;\n// Note: We're skipping the first 32 bytes of `proof`, which holds the size of the dynamically sized `bytes`\nfor (uint256 i = 32; i <= proof.length; i += 32) {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n proofElement := mload(add(proof, i))\n }\n if (j %... | high |
```\n/\*\*\n \* @title Extremely simple implementation of `IStrategy` interface.\n \* @author Layr Labs, Inc.\n \* @notice Simple, basic, "do-nothing" Strategy that holds a single underlying token and returns it on withdrawals.\n \* Assumes shares are always 1-to-1 with the underlyingToken.\n \* @dev Unlike `StrategyBa... | low |
```\nfunction \_stakeDAIx(address \_user, uint256 \_amount, address \_policyBookAddr) internal {\n require (\_amount > 0, "BMIDAIStaking: Can't stake zero tokens");\n\n PolicyBook \_policyBook = PolicyBook(\_policyBookAddr);\n // transfer DAI from PolicyBook to yield generator\n daiToken.transferFrom(\_poli... | high |
```\nfunction add(uint256 a, uint256 b) internal pure returns (uint256) {\n uint256 c = a + b;\n require(c >= a, "SafeMath: addition overflow");\n return c;\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 ||... | low |
```\n uint256 userAmount = balanceOf(msg.sender);\n // - Underlying (Frontend ONLY)\n if (userAmount == 0) {\n user.amount = 0;\n } else {\n user.amount -= r;\n }\n```\n | medium |
```\nfunction isBlacklisted(address account) public view returns(bool) {\n return _isBlackListedBot[account];\n}\n```\n | none |
```\nfunction totalSupply() public view override returns (uint256) {\n return _tTotal;\n}\n```\n | none |
```\nfunction changeFeeReceivers(\n address newTeamWallet,\n address newTreasuryWallet\n) external onlyOwner {\n require(\n newTeamWallet != address(0) && newTreasuryWallet != address(0),\n "New wallets must not be the ZERO address"\n );\n\n teamWallet = newTeamWallet;\n treasuryWallet =... | none |
```\nfunction excludeFromLimit(address account) public onlyOwner {\n _isExcludedFromLimit[account] = true;\n}\n```\n | none |
```\n/// @dev Adds two numbers, reverting on overflow.\nfunction \_add(int256 a, int256 b) private pure returns (int256 c) {\n c = a + b;\n if (c > 0 && a < 0 && b < 0) {\n LibRichErrors.rrevert(LibFixedMathRichErrors.BinOpError(\n LibFixedMathRichErrors.BinOpErrorCodes.SUBTRACTION\_OVERFLOW,\n ... | medium |
```\nfunction priceCollateralToUSD(bytes32 _currencyKey, uint256 _amount) public view override returns(uint256){\n //The LiquidityPool associated with the LP Token is used for pricing\n ILiquidityPoolAvalon LiquidityPool = ILiquidityPoolAvalon(collateralBook.liquidityPoolOf(_currencyKey));\n //we have alre... | medium |
```\nfunction safeTransferFrom(\n IERC20 token,\n address from,\n address to,\n uint256 value\n) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n}\n```\n | none |
```\n function withdrawalRequest(\n uint256 _amount\n ) external nonReentrant onlyWhenVaultIsOn returns (uint256 value) {\n UserInfo storage user = userInfo[msg.sender];\n require(user.withdrawalRequestPeriod == 0, "Already a request");\n\n value = (_amount * exchangeRate) / (10 ** decimals());\n\n _bu... | medium |
```\nfunction _getTValues(uint256 tAmount)\n private\n view\n returns (\n uint256,\n uint256,\n uint256,\n uint256,\n uint256\n )\n{\n uint256 tFee = calculateTaxFee(tAmount);\n uint256 tLiquidity = calculateLiquidityFee(tAmount);\n uint256 tWallet = calculateMark... | none |
```\nfunction registerAddress(bytes32 \_contractName, address \_contractAddress)\n public\n ownerOnly\n validAddress(\_contractAddress)\n{\n```\n | medium |
```\n// 1. Only collect interest if it has been 30 mins\nuint256 timeSinceLastCollection = now.sub(previousCollection);\nif(timeSinceLastCollection > THIRTY\_MINUTES) {\n```\n | high |
```\ncurrentL2BlockNumber = \_finalizationData.finalBlockNumber;\n```\n | high |
```\nfunction process(uint256 gas) public returns (uint256, uint256, uint256)\n{\n uint256 numberOfTokenHolders = tokenHoldersMap.keys.length;\n\n if (numberOfTokenHolders == 0 || dividendsPaused) {\n return (0, 0, lastProcessedIndex);\n }\n\n uint256 _lastProcessedIndex = lastProcessedIndex;\n\n ... | none |
```\nfunction updateSwapTokensAtAmount(uint256 newAmount)\n external\n onlyOwner\n returns (bool)\n{\n require(\n newAmount >= (totalSupply() * 1) / 100000,\n "Swap amount cannot be lower than 0.001% total supply."\n );\n require(\n newAmount <= (totalSupply() * 5) / 1000,\n ... | none |
```\nfunction _latest(\n IMarket market,\n address account\n) internal view returns (Position memory latestPosition, Fixed6 latestPrice, UFixed6 closableAmount) {\n // load parameters from the market\n IPayoffProvider payoff = market.payoff();\n\n // load latest settled position and price\n uint256 la... | medium |
```\nfunction setAuthorization(address address_, bool authorization) external onlyOwner {\n isAuthorized[address_] = authorization;\n}\n```\n | none |
```\n (collateralBalance, currentFees) = _calculateCollateralBalance(\n borrowing.borrowedAmount,\n borrowing.accLoanRatePerSeconds,\n borrowing.dailyRateCollateralBalance,\n accLoanRatePerSeconds\n );\n // rest of code\n ... | medium |
```\n if (amountIn > 0) {\n // We calculate the exchange rate and the amount of underlying to be redeemed:\n // uTokenAmount = amountIn\n // underlyingAmount = amountIn x exchangeRateCurrent\n uTokenAmount = amountIn;\n underlyingAmount = (amountIn * exchangeRate) ... | medium |
```\n self.tokenA.safeTransfer(self.withdrawCache.user, self.tokenA.balanceOf(address(this)));\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 |
```\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 = getVaultBalanc... | medium |
```\nfunction setAllowCustomTokens(bool allow) external onlyOwner {\n require(allowCustomTokens != allow);\n allowCustomTokens = allow;\n emit SetAllowCustomTokens(allow);\n}\n```\n | none |
```\nfunction _reinvestDividendOfUser(address account) private returns (uint256) {\n uint256 _withdrawableDividend = withdrawableDividendOf(account);\n if (_withdrawableDividend > 0) {\n bool success;\n\n withdrawnDividends[account] = withdrawnDividends[account].add(_withdrawableDividend);\n\n ... | none |
```\n {\n IBank.Position memory pos = bank.getCurrentPositionInfo();\n address posCollToken = pos.collToken;\n uint256 collSize = pos.collateralSize;\n address burnToken = address(ISoftVault(strategy.vault).uToken());\n if (collSize > 0) {\n if (posCollToken != address(w... | high |
```\n function updateTrust(address borrower, uint96 trustAmount) external onlyMember(msg.sender) whenNotPaused {\n// rest of code\n uint256 voucheesLength = vouchees[staker].length;\n if (voucheesLength >= maxVouchers) revert MaxVouchees();\n\n\n uint256 voucherIndex = vouchers[borro... | medium |
```\nfunction deleteExcluded(uint index) internal {\n require(index < excludedFromRewards.length, "Index is greater than array length");\n excludedFromRewards[index] = excludedFromRewards[excludedFromRewards.length - 1];\n excludedFromRewards.pop();\n}\n```\n | none |
```\nFile: VaultAccountAction.sol\n require(vaultAccount.lastUpdateBlockTime + Constants.VAULT_ACCOUNT_MIN_TIME <= block.timestamp)\n```\n | medium |
```\nFile: StableMath.sol\n function _calculateInvariant(\n uint256 amplificationParameter,\n uint256[] memory balances,\n bool roundUp\n ) internal pure returns (uint256) {\n /**********************************************************************************************\n // in... | high |
```\n function currentRewardsPerToken() public view returns (uint256) {\n // Rewards do not accrue if the total balance is zero\n if (totalBalance == 0) return rewardsPerTokenStored;\n\n // @audit\n // loss of precision\n // The number of rewards to apply is based on the reward rate a... | medium |
```\n// Emit token transfer\nemit TokenDeposited(contractKey, \_tokenAddress, \_amount, block.timestamp);\n// Done\nreturn true;\n```\n | low |
```\nfunction totalFunds() public view override returns (uint256, uint256) {\n return ConvexPositionHandler.positionInWantToken();\n}\n```\n | high |
```\nif (char == 0x3B) // 0x3B = ';'\n```\n | low |
```\nfunction getERC20Balance(address account, ERC20 token)\n external\n view\n returns (uint256)\n{\n return\n erc20Balances[token][account] +\n (splits[account].hash != 0 ? token.balanceOf(account) : 0);\n}\n```\n | none |
```\nreceive() external payable {}\n```\n | none |
```\nfunction _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {\n (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount);\n _tOwned[sender] = _tOwned[sender] - tAmount;\n _rOwned[sender] = _rOwn... | none |
```\nfunction div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n require(b > 0, errorMessage);\n uint256 c = a / b;\n return c;\n}\n```\n | none |
```\nfunction includeInFee(address account) public onlyOwner {\n _isExcludedFromFee[account] = false;\n emit IncludeInFeeUpdated(account);\n}\n```\n | none |
```\nfunction _getStakeInfo(address addr) internal view returns (StakeInfo memory info) {\n DepositInfo storage depositInfo = deposits[addr];\n info.stake = depositInfo.stake;\n info.unstakeDelaySec = depositInfo.unstakeDelaySec;\n}\n```\n | none |
```\nfunction consult(address token) public view whenNotPaused returns (int256, uint8) {\n address _feed = feeds[token];\n\n if (_feed == address(0)) revert Errors.NoTokenPriceFeedAvailable();\n\n ChainlinkResponse memory chainlinkResponse = _getChainlinkResponse(_feed);\n ChainlinkResponse memory prevChain... | low |
```\nfunction setAutoClaim(address account, bool value) external onlyOwner {\n excludedFromAutoClaim[account] = value;\n}\n```\n | none |
```\nfunction setReinvest(address account, bool value) external onlyOwner {\n autoReinvest[account] = value;\n}\n```\n | none |
```\nfunction checkCollateralRatio(\n VaultConfig memory vaultConfig,\n VaultState memory vaultState,\n VaultAccount memory vaultAccount\n) internal view {\n (int256 collateralRatio, /\* \*/) = calculateCollateralRatio(\n vaultConfig, vaultState, vaultAccount.account, vaultAccount.vaultShares, vaultA... | low |
```\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 |
```\n700/1300 = 0.5384615385 (53%).\n```\n | medium |
```\n IUserManager(userManager).updateLocked(msg.sender, uint96(amount + fee), true);\n …\n IUserManager(userManager).updateLocked(borrower, uint96(repayAmount - interest), false);\n```\n | medium |
```\nconstructor(address payable marketingWalletAddress, address payable buyBackWalletAddress, address payable fairyPotWalletAddress) {\n _marketingWalletAddress = marketingWalletAddress;\n _buyBackWalletAddress = buyBackWalletAddress;\n _fairyPotWalletAddress = fairyPotWalletAddress;\n\n _rOwned[_msgSender... | none |
```\nfunction _getSum(uint32[] memory numbers) internal pure returns (uint32 sum) {\n // overflow should be impossible in for-loop index\n uint256 numbersLength = numbers.length;\n for (uint256 i = 0; i < numbersLength; ) {\n sum += numbers[i];\n unchecked {\n // overflow should be impossible in for-loop ... | none |
```\n function claimRemainings() external {\n if (block.timestamp <= endingTimestamp) {\n revert RedemptionPeriodNotFinished();\n }\n\n // Sending the token to the burning address\n token.transfer(DEAD_ADDRESS, token.balanceOf(address(this)));\n recipient.call{value: address(th... | none |
```\nfunction mulDecode(uint224 x, uint y) internal pure returns (uint) {\n return (x * y) >> RESOLUTION;\n}\n```\n | none |
```\noffTargetPercentage = abs(90 - 100) / (100 + 90) = 10 / 190 = 0.0526 = 5.26%\n```\n | medium |
```\n contract UXDGovernor is\n ReentrancyGuard,\n Governor,\n GovernorVotes,\n GovernorVotesQuorumFraction,\n GovernorTimelockControl,\n GovernorCountingSimple,\n GovernorSettings\n```\n | medium |
```\nfunction functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, "Address: low-level delegate call failed");\n}\n```\n | none |
```\nfunction safeApprove(ERC20 token, address to, uint256 amount) internal {\n bool callStatus;\n\n assembly {\n // Get a pointer to some free memory.\n let freeMemoryPointer := mload(0x40)\n\n // Write the abi-encoded calldata to memory piece by piece:\n mstore(\n freeMemo... | none |
```\nfunction _domainSeparatorV4() internal view returns (bytes32) {\n if (address(this) == _cachedThis && block.chainid == _cachedChainId) {\n return _cachedDomainSeparator;\n } else {\n return _buildDomainSeparator();\n }\n}\n```\n | none |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.