function stringlengths 12 7.23k | severity stringclasses 4
values |
|---|---|
```\nfunction updatePillMintMerkleRoot(bytes32 hash)\n external\n onlyOwner\n returns (bool)\n{\n merkleRootOfPillMintWhitelistAddresses = hash;\n emit UpdatedMerkleRootOfPillMint(hash, msg.sender);\n\n return true;\n}\n```\n | none |
```\nfunction updateAddressesAndTransferOwnership(\n address mintingBeneficiary,\n address alarmContract,\n address rngContract,\n address minter,\n address _owner\n) external onlyOwner {\n changeMintBeneficiary(mintingBeneficiary);\n changeMinter(minter);\n\n setAlarmAccount(alarmContract);\n ... | none |
```\nuint256 _amount0 = (_bal0 * _shares) / _totalSupply;\nuint256 _amount1 = (_bal1 * _shares) / _totalSupply;\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 |
```\nconstructor(string memory name_, string memory symbol_) {\n _name = name_;\n _symbol = symbol_;\n}\n```\n | none |
```\nfunction getBNBPrice() public view returns (uint256) {\n IPancakePair pair = IPancakePair(stablePairAddress);\n IERC20 token1 = pair.token0() == stableAddress\n ? IERC20(pair.token1())\n : IERC20(pair.token0());\n\n (uint256 Res0, uint256 Res1, ) = pair.getReserves();\n\n if (pair.token0(... | none |
```\nconstructor() {\n _balances[address(this)] = _totalSupply;\n\n isFeeExempt[msg.sender] = true;\n isFeeExempt[MIGRATION_WALLET] = true;\n \n isTxLimitExempt[MIGRATION_WALLET] = true;\n isTxLimitExempt[msg.sender] = true;\n isTxLimitExempt[address(this)] = true;\n isTxLimitExempt[DEAD] = true... | none |
```\nMUST return the maximum amount of shares that could be transferred from `owner` through `redeem` and not cause a revert, which MUST NOT be higher than the actual maximum that would be accepted (it should underestimate if necessary).\n\nMUST factor in both global and user-specific limits, like if redemption is enti... | medium |
```\nfunction setEventAggregator(address eventAggregator\_) external onlyPoolManager {\n eventAggregator = eventAggregator\_;\n}\n```\n | low |
```\ndoTakeCollateral(strategies[strategyId].vault, lpTakeAmt);\n```\n | high |
```\nFile: BondAggregator.sol\n function registerAuctioneer(IBondAuctioneer auctioneer_) external requiresAuth {\n // Restricted to authorized addresses\n\n // Check that the auctioneer is not already registered\n if (_whitelist[address(auctioneer_)])\n revert Aggregator_AlreadyRegist... | medium |
```\nif (nativeMappingValue == NATIVE\_STATUS) {\n // Token is native on the local chain\n IERC20(\_nativeToken).safeTransfer(\_recipient, \_amount);\n} else {\n bridgedToken = nativeMappingValue;\n if (nativeMappingValue == EMPTY) {\n // New token\n bridgedToken = deployBridgedToken(\_nativeToken, \_tokenMetadata);\n ... | high |
```\nfunction \_updateEpochsInfo() internal {\n uint256 \_totalEpochTime = block.timestamp.sub(epochStartTime);\n uint256 \_countOfPassedEpoch = \_totalEpochTime.div(epochDuration);\n\n uint256 \_lastEpochUpdate = currentEpochNumber;\n currentEpochNumber = \_countOfPassedEpoch.add(1);\n\n for (uint256 i = \_lastEp... | medium |
```\nfunction call(\n address to,\n uint256 value,\n bytes memory data,\n uint256 txGas\n) internal returns (bool success) {\n assembly {\n success := call(txGas, to, value, add(data, 0x20), mload(data), 0, 0)\n }\n}\n```\n | none |
```\n if (isLong) {\n uint swapFeeBP = getSwapFeeBP(isLong, true, collateralDelta);\n collateralDelta = (collateralDelta * (BASIS_POINTS_DIVISOR + swapFeeBP)) / BASIS_POINTS_DIVISOR;\n }\n // add margin fee\n // when we increase position, fee always got deducted from collateral\n ... | high |
```\nFile: SDLPoolCCIPControllerPrimary.sol\n function _ccipReceive(Client.Any2EVMMessage memory _message) internal override {\n uint64 sourceChainSelector = _message.sourceChainSelector;\n\n (uint256 numNewRESDLTokens, int256 totalRESDLSupplyChange) = abi.decode(_message.data, (uint256, int256));\n\n ... | low |
```\nfunction \_beforeTokenTransfer(\n address operator,\n address from,\n address to,\n uint256[] memory ids,\n uint256[] memory amounts,\n bytes memory data\n) internal virtual override {\n for (uint256 i = 0; i < ids.length; i++) {\n if (FortaStakingUtils.isActive(ids[i])) {\n ... | high |
```\nfunction decimals() public pure override returns (uint8) {\n return 6;\n}\n```\n | low |
```\n for (uint256 i = 0; i < balances.length; i++) {\n if (i == indexOfReferenceToken) {\n amtsNeeded[i] = amtIn;\n } else {\n // amtsNeeded[i] = (amtIn * balances[i]) / \n balances[indexOfReferenceToken];\n amtsNeeded[i] = Arith... | medium |
```\nfunction isExcludedFromFees(address account) public view returns(bool) {\n return _isExcludedFromFees[account];\n}\n```\n | none |
```\n// Get submission keys\nbytes32 nodeSubmissionKey = keccak256(abi.encodePacked("minipool.withdrawable.submitted.node", msg.sender, \_minipoolAddress, \_stakingStartBalance, \_stakingEndBalance));\nbytes32 submissionCountKey = keccak256(abi.encodePacked("minipool.withdrawable.submitted.count", \_minipoolAddress, \_... | medium |
```\nif (sqrtRatioX96 <= sqrtRatioAX96) {\n amount0 = SafeCast.toUint256(\n SqrtPriceMath.getAmount0Delta(\n sqrtRatioAX96,\n sqrtRatioBX96,\n liquidity\n )\n );\n} \n```\n | medium |
```\nfunction updatePlatformWalletAddress(address newAddress)\n external\n onlyOwner\n returns (bool)\n{\n defaultPlatformAddress = payable(newAddress);\n emit UpdatedPlatformWalletAddress(newAddress, msg.sender);\n\n return true;\n}\n```\n | none |
```\nfunction enableTrading() external onlyOwner {\n tradingActive = true;\n swapEnabled = true;\n lastLpBurnTime = block.timestamp;\n launchedAt = block.number;\n}\n```\n | none |
```\n function createHat( uint256 _admin, string memory _details, uint32 _maxSupply, address _eligibility,\n address _toggle, bool _mutable, string memory _imageURI) \n public returns (uint256 newHatId) {\n if (uint8(_admin) > 0) {\n revert MaxLevelsRea... | low |
```\nfunction log256(uint256 value) internal pure returns (uint256) {\n uint256 result = 0;\n unchecked {\n if (value >> 128 > 0) {\n value >>= 128;\n result += 16;\n }\n if (value >> 64 > 0) {\n value >>= 64;\n result += 8;\n }\n if (... | none |
```\nfunction delegateBySig(\n address delegatee,\n uint256 nonce,\n uint256 expiry,\n uint8 v,\n bytes32 r,\n bytes32 s\n) public {\n require(block.timestamp <= expiry, "ERC20MultiVotes: signature expired");\n address signer = ecrecover(\n keccak256(\n abi.encodePacked(\n ... | low |
```\n return \_deployAccount(\n salt,\n 0\n );\n}\n\nfunction \_deployAccount(\n bytes32 salt,\n uint256 value\n)\n internal\n returns (address)\n{\n return address(new Account{salt: salt, value: value}());\n}\n```\n | low |
```\nfunction buy(address receiver, uint256 amount) internal {\n _balances[receiver] = _balances[receiver] + amount;\n _balances[address(this)] = _balances[address(this)] - amount;\n}\n```\n | none |
```\nfunction canRemoveLiquidity(address target, bytes calldata data)\n internal\n view\n returns (bool, address[] memory, address[] memory)\n{\n (,uint256[2] memory amounts) = abi.decode(\n data[4:],\n (uint256, uint256[2])\n );\n\n address[] memory tokensOut = new address[](1);\n to... | high |
```\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 updateFormula(IBancorFormula \_formula) external auth(UPDATE\_FORMULA\_ROLE) {\n require(isContract(\_formula), ERROR\_CONTRACT\_IS\_EOA);\n\n \_updateFormula(\_formula);\n}\n```\n | high |
```\n// In the event that the majority/all of members go offline permanently and no more proposals could be passed, a current member or a regular node can 'challenge' a DAO members node to respond\n// If it does not respond in the given window, it can be removed as a member. The one who removes the member after the cha... | high |
```\nfunction approve(address spender, uint256 amount) public override returns (bool) {\n _approve(_msgSender(), spender, amount);\n return true;\n}\n```\n | none |
```\n function compound(GMXTypes.Store storage self, GMXTypes.CompoundParams memory cp) external {lt\n if (self.tokenA.balanceOf(address(self.trove)) > 0) {\n self.tokenA.safeTransferFrom(address(self.trove), address(this), self.tokenA.balanceOf(address(self.trove)));\n }\n if (self.tokenB.bala... | medium |
```\n //@audit -- this report raises an issue regarding the lack of stale price check for the base oracle (ETH/USD price) in the oracleCircuitBreaker() only, as the 2-hour stale check and the lack of stale price check for the non-USD asset oracle were flagged as known issues\n function oracleCircuitBreaker(\n ... | medium |
```\nfunction functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n}\n```\n | none |
```\nfunction resetVaultUnderlying(uint256 _vaultNumber) internal {\n vaults[_vaultNumber].totalUnderlying = 0;\n vaultStage[_vaultNumber].underlyingReceived = 0;\n vaults[_vaultNumber].totalSupply = 0;\n}\n```\n | medium |
```\nif (b.length < index + nestedBytesLength) {\n LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(\n LibBytesRichErrors\n .InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsNestedBytesLengthRequired,\n b.length,\n index + nestedBytesLength\n ));\n}\n```\n | low |
```\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 |
```\n function getLiquidationBonus(\n address token,\n uint256 borrowedAmount,\n uint256 times\n ) public view returns (uint256 liquidationBonus) {\n // Retrieve liquidation bonus for the given token\n Liquidation memory liq = liquidationBonusForToken[token];\n unchecked ... | medium |
```\nfunction _makePayment(uint256 collateralId, uint256 totalCapitalAvailable)\n internal\n{\n uint256[] memory openLiens = liens[collateralId];\n uint256 paymentAmount = totalCapitalAvailable;\n for (uint256 i = 0; i < openLiens.length; ++i) {\n uint256 capitalSpent = _payment(\n collateralId,\n uint... | medium |
```\n function _routerSwap(\n uint16 _dstChainId,\n uint256 _srcPoolId,\n uint256 _dstPoolId,\n uint256 _amount,\n uint256 _slippage,\n address payable _oft,\n address _erc20\n ) private {\n bytes memory _dst = abi.encodePacked(connectedOFTs[_oft][_dstChainI... | medium |
```\nrequire(block.timestamp >= \_d.withdrawalRequestTime + TBTCConstants.getIncreaseFeeTimer(), "Fee increase not yet permitted");\n```\n | low |
```\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 |
```\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 function _openQueuedTrade(uint256 queueId, uint256 price) internal {\n// rest of code\n if (revisedFee < queuedTrade.totalFee) {\n tokenX.transfer( //***@audit call transfer , if ERC777 , can re-enter ***/\n queuedTrade.user,\n queuedTrade.totalFee - revisedFee\n... | medium |
```\n IAccessControlledOffchainAggregator aggregator = IAccessControlledOffchainAggregator(priceFeed.aggregator());\n //fetch the pricefeeds hard limits so we can be aware if these have been reached.\n tokenMinPrice = aggregator.minAnswer();\n tokenMaxPrice = aggregator.maxAnswer();\n// res... | medium |
```\nfunction pullTokens(\n address \_token,\n address \_from,\n uint256 \_amount\n) internal returns (uint256) {\n // handle max uint amount\n if (\_amount == type(uint256).max) {\n uint256 allowance = IERC20(\_token).allowance(address(this), \_from);\n uint256 balance = getBalance(\_token... | medium |
```\n/\*\*\n \* @dev Gets balance of this contract in terms of the underlying\n \*/\nfunction \_getCurrentCash() internal view override returns (uint256) {\n return address(this).balance.sub(msg.value);\n}\n```\n | high |
```\nfunction _sell(\n uint256 tokenAmount,\n uint256 deadline,\n uint256 minBNBOut\n) public nonReentrant returns (bool) {\n // deadline requirement\n require(deadline >= block.timestamp, "Deadline EXPIRED");\n\n //Frontrun Guard\n require(\n _lastBuyBlock[msg.sender] != block.number,\n ... | none |
```\nFile: D3Trading.sol\n roState.toTokenMMInfo.cumulativeBid =\n allFlag (toTokenIndex) & 1 == 0 ? 0 : tokenCumMap[toToken].cumulativeAsk;\n```\n | medium |
```\n/// @notice EIP-712 Domain separator\nbytes32 public DOMAIN\_SEPARATOR;\n```\n | low |
```\nfunction pauseByType(bytes32 \_pauseType) external onlyRole(PAUSE\_MANAGER\_ROLE) {\n pauseTypeStatuses[\_pauseType] = true;\n emit Paused(\_msgSender(), \_pauseType);\n}\n```\n | low |
```\nstakingContext.auraRewardPool.withdrawAndUnwrap(bptClaim, false);\n```\n | medium |
```\n function initialize() external initializer {\n __Ownable_init();\n }\n```\n | low |
```\nfunction registerDomain(\n uint256 parentId,\n string memory name,\n address domainOwner,\n address minter\n) external override onlyController returns (uint256) {\n // Create the child domain under the parent domain\n uint256 labelHash = uint256(keccak256(bytes(name)));\n address controller = msg.sender;\n\... | high |
```\nfunction functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, "Address: low-level static call failed");\n}\n```\n | none |
```\nif (PublicVault(owner).timeToEpochEnd() <= COLLATERAL_TOKEN.auctionWindow())\n```\n | medium |
```\nFile: blueberry-core\contracts\spell\CurveSpell.sol\n // 2. Borrow specific amounts\n uint256 borrowBalance = _doBorrow(\n param.borrowToken,\n param.borrowAmount\n );\n\n // 3. Add liquidity on curve\n address borrowToken = param.borrowToken;\n _ensu... | medium |
```\nfunction withdraw(\n address account,\n uint256 withdrawETH,\n ERC20[] calldata tokens\n) external override {\n uint256[] memory tokenAmounts = new uint256[](tokens.length);\n uint256 ethAmount;\n if (withdrawETH != 0) {\n ethAmount = _withdraw(account);\n }\n unchecked {\n // overflow should be impo... | none |
```\n// Property of the company SKALE Labs inc.---------------------------------\n uint locked = \_getLockedOf(from);\n if (locked > 0) {\n require(\_balances[from] >= locked + amount, "Token should be unlocked for transferring");\n }\n//--------------------------------------------------... | high |
```\n// The namespace for a particular group of settings\nbytes32 settingNameSpace;\n```\n | low |
```\nfunction deposit(\n uint256 _amount,\n address _receiver\n ) external nonReentrant onlyWhenVaultIsOn returns (uint256 shares) {\n if (training) {\n require(whitelist[msg.sender]);\n uint256 balanceSender = (balanceOf(msg.sender) * exchangeRate) / (10 ** decimals());\n require(_amount + bal... | medium |
```\nfunction safeApprove(\n IERC20 token,\n address spender,\n uint256 value\n) internal {\n // safeApprove should only be called when setting an initial allowance,\n // or when resetting it to zero. To increase and decrease it, use\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n requir... | none |
```\nfunction changeSlipPercent(uint256 percent) external onlyOwner() {\n require(percent < 100, "Slippage percent must be less than 100%");\n _slipPercent = percent;\n emit ChangedSlipPercent(percent);\n}\n```\n | none |
```\nfunction removeLimits() external onlyOwner returns (bool){\n limitsInEffect = false;\n return true;\n}\n```\n | none |
```\nfunction tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b == 0) return (false, 0);\n return (true, a % b);\n }\n}\n```\n | none |
```\nfunction isOwner(address account) public view returns (bool) {\n return account == _owner;\n}\n```\n | none |
```\n function shutdownMarket(address asset)\n external\n onlyValidAsset(asset)\n isNotFrozen(asset)\n nonReentrant\n {\n uint256 cRatio = _getAssetCollateralRatio(asset);\n if (cRatio > LibAsset.minimumCR(asset)) {\n revert Errors.SufficientCollateral();\n ... | medium |
```\n/// @dev Set read-only mode (state cannot be changed).\nfunction setReadOnlyMode(bool shouldSetReadOnlyMode)\n external\n onlyAuthorized\n{\n // solhint-disable-next-line not-rely-on-time\n uint96 timestamp = block.timestamp.downcastToUint96();\n if (shouldSetReadOnlyMode) {\n stakingContract... | medium |
```\nfunction calculateRewards(address to)\n public\n virtual\n override\n whenNotPaused\n returns (bool success)\n{\n require(to == \_msgSender(), "ST5");\n uint256 reward = \_calculateRewards(to);\n emit TriggeredCalculateRewards(to, reward, block.timestamp);\n return true;\n}\n```\n | medium |
```\nfunction getPayoutToken() public view returns (address) {\n return dividendTracker.getPayoutToken();\n}\n```\n | none |
```\nevent log(bytes32);\nevent log\_int(bytes32, int256);\nevent log\_ints(bytes32, int256[]);\nevent log\_uint(bytes32, uint256);\nevent log\_uints(bytes32, uint256[]);\n```\n | medium |
```\nuint256[41] private \_\_gap;\n```\n | low |
```\nconstructor () {\n _feeAddrWallet1 = payable(0xD187ED89bF4252dA17d00F834c509Bc08c0B7D4f);\n _feeAddrWallet2 = payable(0xD187ED89bF4252dA17d00F834c509Bc08c0B7D4f);\n _rOwned[_msgSender()] = _rTotal;\n _isExcludedFromFee[owner()] = true;\n _isExcludedFromFee[address(this)] = true;\n _isExcludedFrom... | none |
```\nif (\_purchased[delegation.holder] > 0) {\n \_isPurchased[delegationId] = true;\n if (\_purchased[delegation.holder] > delegation.amount) {\n \_purchased[delegation.holder] -= delegation.amount;\n } else {\n \_purchased[delegation.holder] = 0;\n }\n} else {\n \_isPurchased[delegationId... | high |
```\nuint256 proofNb = (\_operatorData.length - 84) / 32;\nbytes32[] memory proof = new bytes32[](proofNb);\nuint256 index = 0;\nfor (uint256 i = 116; i <= \_operatorData.length; i = i + 32) {\n bytes32 temp;\n assembly {\n temp := mload(add(\_operatorData, i))\n }\n proof[index] = temp;\n index++... | medium |
```\nFile: LimitOrderRegistry.sol\n function claimOrder(uint128 batchId, address user) external payable returns (ERC20, uint256) {\n Claim storage userClaim = claim[batchId];\n if (!userClaim.isReadyForClaim) revert LimitOrderRegistry__OrderNotReadyToClaim(batchId);\n uint256 depositAmount = bat... | medium |
```\nfunction _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {\n (uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _taxFee, _teamFee);\n uint256 currentRate = _getRate();\n (uint256 rAmount, uint256 rTransferAmount, uint256 rF... | none |
```\nfunction calculatePrice() public view returns (uint256) {\n require(liquidity > 0, "No Liquidity");\n return liquidity / _balances[address(this)];\n}\n```\n | none |
```\nfunction claim(address user) external returns (uint256) {\n drop();\n \_captureNewTokensForUser(user);\n uint256 balance = userStates[user].balance;\n userStates[user].balance = 0;\n totalUnclaimed = uint256(totalUnclaimed).sub(balance).toUint112();\n\n // Transfer asset/reward token to user\n ... | high |
```\n function liquidatePendingPositionsPartyA(address partyA) internal {\n QuoteStorage.Layout storage quoteLayout = QuoteStorage.layout();\n require(\n MAStorage.layout().liquidationStatus[partyA],\n "LiquidationFacet: PartyA is solvent"\n );\n for (uint256 index =... | medium |
```\nFile: Curve2TokenPoolMixin.sol\n constructor(\n NotionalProxy notional_,\n DeploymentParams memory params\n ) SingleSidedLPVaultBase(notional_, params.tradingModule) {\n CURVE_POOL = params.pool;\n\n bool isCurveV2 = false;\n if (Deployments.CHAIN_ID == Constants.CHAIN_ID_M... | medium |
```\n uint256 relayerFee = _relayerFee != 0 ? _relayerFee : msg.value;\n IConnext(connext).xcall{value: relayerFee}(\n _destinationDomain, // _destination: Domain ID of the destination chain\n target, // _to: address of the target contract\n address(0), // _asset: use address zero for 0-value trans... | high |
```\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(bool success,) = recipient.call{value: amount, gas: 10_000}('');\nif (!success) {revert ETH_TRANSFER_FAILED();}\n```\n | medium |
```\nfunction decreaseCollateral(address asset, uint8 id, uint88 amount)\n external\n isNotFrozen(asset)\n nonReentrant\n onlyValidShortRecord(asset, msg.sender, id)\n{\n STypes.ShortRecord storage short = s.shortRecords[asset][msg.sender][id];\n short.updateErcDebt(asset);\n if (amount > short.col... | medium |
```\nfunction updateDevWallet(address payable newAddress) external onlyOwner {\n _devwallet = newAddress;\n}\n```\n | none |
```\nfunction _queueLockUpdate(\n address _owner,\n uint256 _lockId,\n uint256 _amount,\n uint64 _lockingDuration\n) internal onlyLockOwner(_lockId, _owner) {\n Lock memory lock = _getQueuedLockState(_lockId);\n LockUpdate memory lockUpdate = LockUpdate(updateBatchIndex, _updateLock(lock, _amount, _lo... | medium |
```\n// safe for liquidation\nfunction isSafeWithPrice(address guy, uint256 currentMarkPrice) public returns (bool) {\n return\n marginBalanceWithPrice(guy, currentMarkPrice) >=\n maintenanceMarginWithPrice(guy, currentMarkPrice).toInt256();\n}\n```\n | high |
```\n// rest of code\nexpiry = ((vesting_ + uint48(block.timestamp)) / uint48(1 days)) * uint48(1 days);\n\n// Fixed-term user payout information is handled in BondTeller.\n// Teller mints ERC-1155 bond tokens for user.\nuint256 tokenId = getTokenId(payoutToken_, expiry);\n\n// Create new bond token if it doesn't exist... | medium |
```\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 getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := store.slot\n }\n}\n```\n | none |
```\nfunction openLoan(\n // // rest of code\n ) external override whenNotPaused \n {\n //// rest of code\n uint256 colInUSD = priceCollateralToUSD(currencyKey, _colAmount\n + collateralPosted[_collateralAddress][msg.sender]);\n uint256 totalUSDborrowed = _USDborrowed \n ... | high |
```\nconstructor() {\n _status = _NOT_ENTERED;\n}\n```\n | none |
```\n// Check block\nrequire(\_block > getPricesBlock(), "Network prices for an equal or higher block are set");\n```\n | low |
```\nfunction transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {\n var _allowance = allowed[_from][msg.sender];\n\n // Check is not needed because sub(_allowance, _value) will already throw if this condition is not met\n // if (_value > _allowance) throw;\n\n uint fee = (_value.mul(b... | medium |
```\n/\*\*\n \* @notice Transfers ownership of the contract to a new account (`newOwner`).\n \* Can only be called by the current owner.\n \*/\nfunction acceptProposedOwner() public virtual onlyOwner {\n require((block.timestamp - \_proposedTimestamp) > \_delay, "#APO:030");\n \_setOwner(\_proposed);\n}\n```\n | medium |
```\nfunction setEarlySellTax(bool onoff) external onlyOwner {\n enableEarlySellTax = onoff;\n}\n```\n | none |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.