function stringlengths 12 63.3k | severity stringclasses 4
values |
|---|---|
```\nfunction transferEther(address payable to, uint256 amount) public {\n to.transfer(amount);\n\n emit TransferredEther(to, amount);\n}\n```\n | low |
```\nFile: StableModule.sol\n function executeDeposit(\n address _account,\n uint64 _executableAtTime,\n FlatcoinStructs.AnnouncedStableDeposit calldata _announcedDeposit\n ) external whenNotPaused onlyAuthorizedModule returns (uint256 _liquidityMinted) {\n uint256 depositAmount = _ann... | medium |
```\nfunction reimbursementAirdrop(\n address[] memory addresses,\n uint256[] memory values\n) external returns (bool) {\n if (\n (block.timestamp >= defaultSaleStartTime) &&\n (block.timestamp <\n defaultSaleStartTime + DEFAULT_INITIAL_PUBLIC_SALE)\n ) revert CannotClaimReimburseme... | none |
```\n uint extraRewardsCount = IAuraRewarder(crvRewarder)\n .extraRewardsLength();\n tokens = new address[](extraRewardsCount + 1);\n rewards = new uint256[](extraRewardsCount + 1);\n\n tokens[0] = IAuraRewarder(crvRewarder).rewardToken();\n rewards[0] = _getPendingReward(\n stCrvPerShare,\... | medium |
```\nfunction _transfer(\n address from,\n address to,\n uint256 amount\n) internal override {\n require(from != address(0), "ERC20: transfer from the zero address");\n require(to != address(0), "ERC20: transfer to the zero address");\n\n if (amount == 0) {\n super._transfer(from, to, 0);\n ... | none |
```\n/\*\*\n @notice Authorizes a controller to control the registrar\n @param controller The address of the controller\n \*/\nfunction addController(address controller) external override onlyOwner {\n controllers[controller] = true;\n emit ControllerAdded(controller);\n}\n\n/\*\*\n @notice Unauthorizes a controller ... | low |
```\nfunction recoverETH() external onlyOwner() {\n uint256 contractETHBalance = address(this).balance;\n sendETHToFee(contractETHBalance);\n}\n```\n | none |
```\n function borrow(\n uint256 amount,\n address to,\n bool isDepositToJOJO\n ) external override nonReentrant nonFlashLoanReentrant{\n // t0BorrowedAmount = borrowedAmount / getT0Rate\n DataTypes.UserInfo storage user = userInfo[msg.sender];\n _borrow(user, isDepo... | medium |
```\nconstructor() {\n _transferOwnership(_msgSender());\n}\n```\n | none |
```\nfunction _claimDeposit(\n address owner,\n address receiver\n)\n internal\n returns (uint256 shares)\n{\n shares = previewClaimDeposit(owner);\n\n uint256 lastRequestId = lastDepositRequestId[owner];\n uint256 assets = epochs[lastRequestId].depositRequestBalance[owner];\n epochs[lastRequest... | high |
```\n struct tradeInput { \n address spendToken;\n address receiveToken;\n uint256 spendAmt;\n uint256 receiveAmtMin;\n address routerAddress;\n uint256 pathIndex;\n }\n```\n | high |
```\nfunction sub(uint256 a, uint256 b) internal pure returns (uint256) {\n return sub(a, b, "SafeMath: subtraction overflow");\n}\n```\n | none |
```\nfunction safeTransfer(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 freeMem... | none |
```\n// transfer the assets into the pool\n// whatever we couldn't pay back\nuint256 lostAmt = principalOwed > recoveredFunds ? principalOwed - recoveredFunds : 0;\n\nuint256 totalOwed = interestPaid + principalOwed;\n\nasset.transferFrom(\n msg.sender,\n address(this),\n totalOwed > recoveredFunds ? recoveredFunds : t... | high |
```\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 |
```\nuint256[41] private \_\_gap;\n```\n | low |
```\nfunction withdraw(uint256 amount, address payable destination) public {\n require(\n unbondedValue[msg.sender] >= amount,\n "Insufficient unbonded value"\n );\n\n unbondedValue[msg.sender] -= amount;\n\n (bool success, ) = destination.call.value(amount)("");\n require(success, "Transfe... | low |
```\nconstructor(\n address feeCollector_,\n address admin_,\n address validator_,\n address feeOracle_,\n address unlockSigner_\n) {\n feeCollector = feeCollector_;\n validator = validator_;\n feeOracle = feeOracle_;\n _setupRole(DEFAULT_ADMIN_ROLE, admin_);\n unlockSigner = unlockSigner_... | none |
```\n/// @notice Redeems tokens from the yield source from the msg.sender, it burn yield bearing tokens and return token to the sender.\n/// @param amount The amount of `token()` to withdraw. Denominated in `token()` as above.\n/// @return The actual amount of tokens that were redeemed.\nfunction redeemToken(uint256 am... | medium |
```\nl.availableCollateral[oldBidder] += l.highestBids[tokenId][currentAuctionRound].bidAmount;\n```\n | medium |
```\nfunction setSwapTokensAtAmount(uint256 _newAmount) external onlyOwner {\n require(_newAmount > 0 && _newAmount <= (_totalSupply * 5) / 1000, "Minimum swap amount must be greater than 0 and less than 0.5% of total supply!");\n swapTokensAtAmount = _newAmount;\n emit SwapThresholdUpdated(swapTokensAtAmount)... | none |
```\nfunction \_deposit(uint256 \_amount, address \_tranche) internal returns (uint256 \_minted) {\n // check that we are not depositing more than the contract available limit\n \_guarded(\_amount);\n // set \_lastCallerBlock hash\n \_updateCallerBlock();\n // check if strategyPrice decreased\n \_checkDefault();\... | medium |
```\nfunction getExcludedBalances() internal view returns (uint256) {\n uint256 totalExcludedHoldings = 0;\n for (uint i = 0; i < excludedFromRewards.length; i++) {\n totalExcludedHoldings += balanceOf(excludedFromRewards[i]);\n }\n return totalExcludedHoldings;\n}\n```\n | none |
```\nrequire(\n IERC20(vaultInfo.vaultAddress).totalSupply() +\n pendingDeposit -\n pendingWithdrawal +\n amountIn <=\n vaultInfo.maxAmount,\n "MAX\_LIMIT\_EXCEEDED"\n);\n```\n | low |
```\nenum ProposalType {\n Invite, // Invite a registered node to join the trusted node DAO\n Leave, // Leave the DAO\n Replace, // Replace a current trusted node with a new registered node, they take over their bond\n Kick, // Kick a member from the DAO wit... | low |
```\nfunction getLotPriceByTotalBids(uint256 \_index) override public view returns (uint256) {\n uint256 calcBase = 1 ether;\n return calcBase.mul(getLotTotalBidAmount(\_index)).div(getLotTotalRPLAmount(\_index));\n}\n```\n | low |
```\n/\*\*\n \* @notice Checks that a leaf hash is contained in a root hash\n \* @param leaf Leaf hash to verify\n \* @param index Position of the leaf hash in the Merkle tree\n \* @param rootHash Root of the Merkle tree\n \* @param proof A Merkle proof demonstrating membership of the leaf hash\n \* @return True, if th... | medium |
```\nfunction transfer(address recipient, uint amount) external override returns (bool) {\n return doTransfer(msg.sender, recipient, amount);\n}\n```\n | none |
```\nfunction toSharesGlobal(Checkpoint memory self, UFixed6 assets) internal pure returns (UFixed6) {\n // vault is fresh, use par value\n if (self.shares.isZero()) return assets;\n\n // if vault is insolvent, default to par value\n return self.assets.lte(Fixed6Lib.ZERO) ? assets : _toShares(self, _withou... | medium |
```\n function sellUnderlying(\n address u,\n uint256 m,\n uint128 a,\n uint128 s\n ) external returns (uint128) {\n // Get the pool for the market\n IPool pool = IPool(pools[u][m]);\n\n // Get the number of PTs received for selling `a` underlying tokens\n u... | medium |
```\n/// @notice Set the system signer fee divisor.\n/// @param \_signerFeeDivisor The signer fee divisor.\nfunction setSignerFeeDivisor(uint256 \_signerFeeDivisor)\n external onlyOwner\n{\n require(\_signerFeeDivisor > 9, "Signer fee divisor must be greater than 9, for a signer fee that is <= 10%.");\n signer... | high |
```\n// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport "forge-std/Test.sol";\nimport "../contracts/role/RoleStore.sol";\nimport "../contracts/router/ExchangeRouter.sol";\nimport "../contracts/data/DataStore.sol";\nimport "../contracts/referral/ReferralStorage.sol";\n\nimport "../contracts/token/IWNT.so... | medium |
```\nfunction borrow(VerifiableCredential memory vc) external isOpen subjectIsAgentCaller(vc) {\n // 1e18 => 1 FIL, can't borrow less than 1 FIL\n if (vc.value < WAD) revert InvalidParams();\n // can't borrow more than the pool has\n if (totalBorrowableAssets() < vc.value) revert InsufficientLiquidity();\n Account memo... | high |
```\nstruct StoredTriggerOrder {\n /* slot 0 */\n uint8 side; // 0 = maker, 1 = long, 2 = short, 3 = collateral\n int8 comparison; // -2 = lt, -1 = lte, 0 = eq, 1 = gte, 2 = gt\n uint64 fee; // <= 18.44tb\n int64 price; // <= 9.22t\n int64 delta; ... | medium |
```\nfunction add(int256 a, int256 b) internal pure returns (int256) {\n int256 c = a + b;\n require((b >= 0 && c >= a) || (b < 0 && c < a));\n return c;\n}\n```\n | none |
```\nfunction didLastOptionalReturnCallSucceed(\n bool callStatus\n) private pure returns (bool success) {\n assembly {\n // Get how many bytes the call returned.\n let returnDataSize := returndatasize()\n\n // If the call reverted:\n if iszero(callStatus) {\n // Copy the re... | none |
```\nuint256 currencyAmount = Math.ceilDiv(\n \_arguments.tokenAmount \* \_arguments.tokenPrice,\n 10 \*\* \_arguments.token.decimals()\n);\n```\n | low |
```\nfunction setAdmin(address adminAddress) external onlyOwner() {\n admin = adminAddress;\n}\n```\n | none |
```\nfunction fromSystemPrecision(uint256 amount, uint8 precision)\n private\n pure\n returns (uint256)\n{\n if (precision > SYSTEM_PRECISION) {\n return amount * (10**(precision - SYSTEM_PRECISION));\n } else if (precision < SYSTEM_PRECISION) {\n return amount / (10**(SYSTEM_PRECISION - pr... | none |
```\n// If TP < NP\nBPF = bondFactor * min(1, max(-1, (NP - price) / (NP - TP)))\n\n// If TP >= NP\nBPF = bondFactor (if price <= NP)\nBPF = -bondFactor (if price > NP)\n```\n | medium |
```\nfunction div(uint256 a, uint256 b) internal pure returns (uint256) {\n return a / b;\n}\n```\n | none |
```\nfunction mul(uint256 a, uint256 b) internal pure returns (uint256) {\n if (a == 0) {\n return 0;\n }\n uint256 c = a * b;\n require(c / a == b, "SafeMath: multiplication overflow");\n return c;\n}\n```\n | none |
```\nall: clean solc\n```\n | low |
```\nrequire(\n (DATASTORE.readUintForId(operatorId, "totalActiveValidators") +\n pubkeys.length) <= self.TELESCOPE.MONOPOLY\_THRESHOLD,\n "StakeUtils: IceBear does NOT like monopolies"\n);\n```\n | medium |
```\nfunction addTokenPriceFeed(address token, address feed) external onlyOwner {\n if (token == address(0)) revert Errors.ZeroAddressNotAllowed();\n if (feed == address(0)) revert Errors.ZeroAddressNotAllowed();\n if (feeds[token] != address(0)) revert Errors.TokenPriceFeedAlreadySet();\n\n feeds[token] = feed;\n}... | medium |
```\nfunction verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n) internal pure returns (bytes memory) {\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 ... | none |
```\nfunction calculateTaxFee(uint256 _amount) private view returns (uint256) {\n return (_amount * _taxFee) / (10**2);\n}\n```\n | none |
```\nif (!isContract(target)) Errors.AddressNotContract;\n```\n | medium |
```\nfunction _setOwner(address newOwner) private {\n address oldOwner = _owner;\n _owner = newOwner;\n emit OwnershipTransferred(oldOwner, newOwner);\n}\n```\n | none |
```\n function rebase(uint32 _l2Gas) external {\n inflationMultiplier = IECO(l1Eco).getPastLinearInflation(\n block.number\n );\n\n bytes memory message = abi.encodeWithSelector(\n IL2ECOBridge.rebase.selector,\n inflationMultiplier\n );\n\n sendCro... | high |
```\n_supplied = 100\n_totalSupply = 100\n\n_interest = 10\nfee = 2\n```\n | medium |
```\n## Balancer.sol\n\nfunction _sendToken(\n address payable _oft,\n uint256 _amount,\n uint16 _dstChainId,\n uint256 _slippage,\n> bytes memory _data\n ) private {\n address erc20 = ITOFT(_oft).erc20();\n if (IERC20Metadata(erc20).balanceOf(address(this)) < _amount... | medium |
```\nuint256 premium = amount\_.mul(policy.weeklyPremium).div(RATIO\_BASE);\nuint256 allPremium = premium.mul(toWeek\_.sub(fromWeek\_));\n```\n | medium |
```\nfunction execute(address to, bytes calldata data, uint256 value) external onlyOwner returns (bytes memory){\n require(to != address(0));\n-> (bool success, bytes memory returnData) = to.call{value: value}(data);\n if (!success) {\n assembly {\n let ptr := mload(0x40)\n ... | medium |
```\nFile: LMPVault.sol\n function redeem(\n uint256 shares,\n address receiver,\n address owner\n ) public virtual override nonReentrant noNavDecrease ensureNoNavOps returns (uint256 assets) {\n uint256 maxShares = maxRedeem(owner);\n if (shares > maxShares) {\n reve... | medium |
```\n function _addFounders(IManager.FounderParams[] calldata _founders, uint256 reservedUntilTokenId) internal {\n// rest of code\n\n // Used to store the base token id the founder will recieve\n uint256 baseTokenId = reservedUntilTokenId;\n\n // For each token to vest:\n ... | high |
```\nfunction setDividendsPaused(bool value) external onlyOwner {\n require(dividendsPaused != value);\n dividendsPaused = value;\n emit DividendsPaused(value);\n}\n```\n | none |
```\n(obtainedPremium, ) = dvp.premium(params.strike, params.notionalUp, params.notionalDown);\n```\n | medium |
```\nfunction updateUsedBorrowCapacity(\n address vault,\n uint16 currencyId,\n int256 netfCash\n) internal returns (int256 totalUsedBorrowCapacity) {\n VaultBorrowCapacityStorage storage cap = LibStorage.getVaultBorrowCapacity()[vault][currencyId];\n\n // Update the total used borrow capacity, when borr... | low |
```\n// MigrateWithdrawal will turn a LegacyWithdrawal into a bedrock\n// style Withdrawal.\nfunc MigrateWithdrawal(withdrawal *LegacyWithdrawal, l1CrossDomainMessenger *common.Address) (*Withdrawal, error) {\n // Attempt to parse the value\n value, err := withdrawal.Value()\n if err != nil {\n return nil, fmt.Errorf(... | medium |
```\nif (name(stake.left\_) == key) {\n current.right\_ = stake.right\_;\n current.after\_ = stake.after\_;\n} else {\n current.left\_ = stake.left\_;\n current.before\_ = stake.before\_;\n}\n```\n | high |
```\nFile: SingleSidedLPVaultBase.sol\n /// @notice Restores withdrawn tokens from emergencyExit back into the vault proportionally.\n /// Unlocks the vault after restoration so that normal functionality is restored.\n /// @param minPoolClaim slippage limit to prevent front running\n function restoreVault(\... | high |
```\n if (uint256(expiry) < block.timestamp) revert Teller_OptionExpired(expiry);\n```\n | medium |
```\nFile: GMXVault.sol\n\n function deposit(GMXTypes.DepositParams memory dp) external payable nonReentrant {\n GMXDeposit.deposit(_store, dp, false);\n }\n```\n | medium |
```\nif (vrfRequests[_requestId].fulfilled) revert InvalidVrfState();\n```\n | high |
```\nuint tokenInRatio = bdiv(newTokenBalanceIn, tokenBalanceIn);\n\n// uint newPoolSupply = (ratioTi ^ weightTi) \* poolSupply;\nuint poolRatio = bpow(tokenInRatio, normalizedWeight);\n```\n | low |
```\nfunction _transferFromExcluded(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 addLiquidity() external onlyOwner() {\n IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);\n uniswapV2Router = _uniswapV2Router;\n _approve(address(this), address(uniswapV2Router), _tTotal);\n uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router... | none |
```\nfunction setDevelopmentAddress(address _newaddress) external onlyOwner {\n require(_newaddress != address(0), "can not set marketing to dead wallet");\n DevelopmentAddress = payable(_newaddress);\n emit DevelopmentAddressChanged(_newaddress);\n}\n```\n | none |
```\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 includeInLimit(address account) public onlyOwner {\n _isExcludedFromLimit[account] = false;\n}\n```\n | none |
```\nfunction cancelAuction(uint96 lotId_) external override onlyInternal {\n _revertIfLotConcluded(lotId_);\n}\n```\n | high |
```\n // Allow the challenged member to refute the challenge at anytime. If the window has passed and the challenge node does not run this method, any member can decide the challenge and eject the absent member\n // Is it the node being challenged?\n if(\_nodeAddress == msg.sender) {\n // Challenge is d... | low |
```\namount = balance() * shares / totalSupply();\n```\n | medium |
```\nfunction Sweep() external onlyOwner {\n uint256 amountETH = address(this).balance;\n payable(msg.sender).transfer(amountETH);\n}\n```\n | none |
```\nfor (uint256 i; i < numberOfRounds; ++i) {\n uint256 roundId = _unsafeAdd(startingRoundId, i);\n Round storage round = rounds[roundId];\n uint256 roundValuePerEntry = round.valuePerEntry;\n if (roundValuePerEntry == 0) {\n (, , roundValuePerEntry) = _write... | high |
```\n bool cancelled = l.Auction.isCancelled(lastEpoch);\n bool finalized = l.Auction.isFinalized(lastEpoch);\n\n require(\n (!finalized && cancelled) || (finalized && !cancelled),\n "auction is not finalized nor cancelled"\n );\n```\n | medium |
```\n while (i < withdrawals.length && (i - start) < maxWithdrawalProcesses) {\n Withdrawal memory withdrawal = withdrawals[i];\n if (reserve < withdrawal.amount) {\n break;\n }\n\n (bool success, bytes memory data) = withdrawal.usr.call{value: withdrawal.amount}("");\n ... | medium |
```\nFile: TokenUtils.sol\n function checkApprove(IERC20 token, address spender, uint256 amount) internal {\n if (address(token) == address(0)) return;\n\n IEIP20NonStandard(address(token)).approve(spender, amount);\n _checkReturnCode();\n }\n```\n | medium |
```\nconstructor(address[] memory blockedAddresses) {\n for (uint i = 0; i < blockedAddresses.length; ) {\n blocklist[blockedAddresses[i]] = true;\n unchecked {\n i += 1;\n }\n }\n}\n```\n | none |
```\nfunction symbol() public view returns (string memory) {\n return _symbol;\n}\n```\n | none |
```\nfunction changeBaseURI(string memory newBaseURI)\n public\n onlyOwner\n notLocked\n{\n require((keccak256(abi.encodePacked((_baseTokenURI))) != keccak256(abi.encodePacked((newBaseURI)))), "DCBW721: Base URI cannot be same as previous");\n _baseTokenURI = newBaseURI;\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 getLastProcessedIndex() external view returns (uint256) {\n return lastProcessedIndex;\n}\n```\n | none |
```\nunchecked {\n for (uint256 i = 0; i < claimCount; ++i) {\n // Load claim in memory\n MerkleClaim memory claim = claims[I];\n\n // Requires one proof per tokenId to handle cases where users want to partially claim\n if (!MerkleProof.verify(claim.merkleProof, settings.merkleRoot, kecca... | medium |
```\nfunction registerAddress(bytes32 \_contractName, address \_contractAddress)\n public\n ownerOnly\n validAddress(\_contractAddress)\n{\n```\n | medium |
```\nfunction getNumberOfDividendTokenHolders() external view returns (uint256) {\n return dividendTracker.getNumberOfTokenHolders();\n}\n```\n | none |
```\nfunction remove(Map storage map, address key) internal {\n if (!map.inserted[key]) {\n return;\n }\n\n delete map.inserted[key];\n delete map.values[key];\n\n uint256 index = map.indexOf[key];\n uint256 lastIndex = map.keys.length - 1;\n address lastKey = map.keys[lastIndex];\n\n map... | none |
```\n for (uint32 index = 0; index < params.length; index++) {\n OpenTradeParams memory currentParams = params[index];\n QueuedTrade memory queuedTrade = queuedTrades[\n currentParams.queueId\n ];\n bool isSignerVerifed = _validateSigner(\n currentParams.timestamp,\n... | high |
```\n function claim() external {\n checkingEpoch();\n require(\n uint8(epoch) > 1 && !admin.blockClaim(address(this)),\n "TokenSale: Not time or not allowed"\n );\n\n Staked storage s = stakes[msg.sender];\n require(s.amount != 0, "TokenSale: No Deposit"); \n ... | high |
```\nfunction getRoleAdmin(bytes32 role) public view override returns (bytes32) {\n return _roles[role].adminRole;\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 swapTokensForEth(uint256 tokenAmount) private {\n\n address[] memory path = new address[](2);\n path[0] = address(this);\n path[1] = uniswapV2Router.WETH();\n\n _approve(address(this), address(uniswapV2Router), tokenAmount);\n\n uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTo... | none |
```\n if(outstandingisoUSD >= TENTH_OF_CENT){ //ignore leftover debts less than $0.001\n uint256 collateralLeft = collateralPosted[_collateralAddress][msg.sender] - _collateralToUser;\n uint256 colInUSD = priceCollateralToUSD(currencyKey, collateralLeft); \n uint256 borrowMargin = (outstandingis... | high |
```\nfor (uint i = 0; i < \_blockheaders.length; i++) {\n (calcParent, calcBlockhash) = getParentAndBlockhash(\_blockheaders[i]);\n if (calcBlockhash != currentBlockhash) {\n return 0x0;\n }\n currentBlockhash = calcParent;\n}\n```\n | medium |
```\nbptClaim = (strategyTokenAmount * context.totalBPTHeld) / context.vaultState.totalStrategyTokenGlobal;\n1,000,999 = (1000000 * 1002000) / 1001000\n```\n | medium |
```\nfunction uniswapV3MintCallback(\n uint256 amount0,\n uint256 amount1,\n bytes calldata data\n) external override {\n require(msg.sender == address(pool));\n address payer = abi.decode(data, (address));\n\n if (payer == address(this)) {\n if (amount0 > 0) token0.safeTransfer(msg.sender, amo... | low |
```\nfunction safeTransferFrom(\n ERC20 token,\n address from,\n address to,\n uint256 amount\n) 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 pie... | none |
```\n// request version\nif (!newOrder.isEmpty()) oracle.request(IMarket(this), account);\n```\n | high |
```\nfunction checkSaleType() external view returns (SaleType activeSale) {\n if (block.timestamp < defaultSaleStartTime) {\n return SaleType.NotStarted;\n } else if (\n (block.timestamp >= defaultSaleStartTime) &&\n (block.timestamp <\n defaultSaleStartTime + DEFAULT_INITIAL_PUBLI... | none |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.