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 = _announcedDeposit.depositAmount;\n\n uint32 maxAge = _getMaxAge(_executableAtTime);\n\n _liquidityMinted = (depositAmount * (10 ** decimals())) / stableCollateralPerShare(maxAge);\n\n if (_liquidityMinted < _announcedDeposit.minAmountOut)\n revert FlatcoinErrors.HighSlippage(_liquidityMinted, _announcedDeposit.minAmountOut);\n\n _mint(_account, _liquidityMinted);\n\n vault.updateStableCollateralTotal(int256(depositAmount));\n\n if (totalSupply() < MIN_LIQUIDITY) // @audit-info MIN_LIQUIDITY = 10_000\n revert FlatcoinErrors.AmountTooSmall({amount: totalSupply(), minAmount: MIN_LIQUIDITY});\n```\n | 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 CannotClaimReimbursementInPublicMint();\n\n if (msg.sender != defaultPlatformAddress) revert UnAuthorizedRequest();\n\n if (addresses.length != values.length) revert UnAuthorizedRequest();\n\n for (uint256 i = 0; i < addresses.length; i++) {\n (bool sent, ) = addresses[i].call{value: values[i]}("");\n if (!sent) revert AirdropTransactionFailed(addresses[i], values[i]);\n }\n\n emit ReimbursementClaimedOfPublicSale(addresses, values);\n return true;\n}\n```\n | 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,\n crvRewarder,\n amount,\n lpDecimals\n );\n\n for (uint i = 0; i < extraRewardsCount; i++) {\n address rewarder = IAuraRewarder(crvRewarder).extraRewards(i);\n uint256 stRewardPerShare = accExtPerShare[tokenId][i];\n tokens[i + 1] = IAuraRewarder(rewarder).rewardToken();\n rewards[i + 1] = _getPendingReward(\n stRewardPerShare,\n rewarder,\n amount,\n lpDecimals\n );\n }\n```\n | 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 return;\n }\n\n if (limitsEnabled) {\n if (\n from != owner() &&\n to != owner() &&\n to != address(0) &&\n to != address(0xdead) &&\n !swapping\n ) {\n if (!tradingEnabled) {\n require(\n transferTaxExempt[from] || transferTaxExempt[to],\n "_transfer:: Trading is not active."\n );\n }\n\n // at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.\n if (transferDelayEnabled) {\n if (\n to != owner() &&\n to != address(dexRouter) &&\n to != address(dexPair)\n ) {\n require(\n _holderLastTransferTimestamp[tx.origin] <\n block.number,\n "_transfer:: Transfer Delay enabled. Only one purchase per block allowed."\n );\n _holderLastTransferTimestamp[tx.origin] = block.number;\n }\n }\n\n //when buy\n if (\n automatedMarketMakerPairs[from] && !transferLimitExempt[to]\n ) {\n require(\n amount <= maxTx,\n "Buy transfer amount exceeds the maxTx."\n );\n require(\n amount + balanceOf(to) <= maxWallet,\n "Max wallet exceeded"\n );\n }\n //when sell\n else if (\n automatedMarketMakerPairs[to] && !transferLimitExempt[from]\n ) {\n require(\n amount <= maxTx,\n "Sell transfer amount exceeds the maxTx."\n );\n } else if (!transferLimitExempt[to]) {\n require(\n amount + balanceOf(to) <= maxWallet,\n "Max wallet exceeded"\n );\n }\n }\n }\n\n uint256 contractTokenBalance = balanceOf(address(this));\n\n bool canSwap = contractTokenBalance >= swapBackValueMin;\n\n if (\n canSwap &&\n swapbackEnabled &&\n !swapping &&\n !automatedMarketMakerPairs[from] &&\n !transferTaxExempt[from] &&\n !transferTaxExempt[to]\n ) {\n swapping = true;\n\n swapBack();\n\n swapping = false;\n }\n\n bool takeFee = !swapping;\n\n // if any account belongs to _isExcludedFromFee account then remove the fee\n if (transferTaxExempt[from] || transferTaxExempt[to]) {\n takeFee = false;\n }\n\n uint256 fees = 0;\n // only take fees on buys/sells, do not take on wallet transfers\n if (takeFee) {\n // on sell\n if (automatedMarketMakerPairs[to] && sellTaxTotal > 0) {\n fees = amount.mul(sellTaxTotal).div(100);\n tokensForProject += (fees * sellProjectTax) / sellTaxTotal;\n tokensForMarketing += (fees * sellMarketingTax) / sellTaxTotal;\n }\n // on buy\n else if (automatedMarketMakerPairs[from] && buyTaxTotal > 0) {\n fees = amount.mul(buyTaxTotal).div(100);\n tokensForProject += (fees * buyProjectTax) / buyTaxTotal;\n tokensForMarketing += (fees * buyMarketingTax) / buyTaxTotal;\n }\n\n if (fees > 0) {\n super._transfer(from, address(this), fees);\n }\n\n amount -= fees;\n }\n\n super._transfer(from, to, amount);\n}\n```\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 to control the registrar\n @param controller The address of the controller\n \*/\nfunction removeController(address controller) external override onlyOwner {\n controllers[controller] = false;\n emit ControllerRemoved(controller);\n}\n```\n | 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, isDepositToJOJO, to, amount, msg.sender);\n require(\n _isAccountSafeAfterBorrow(user, getTRate()),\n JUSDErrors.AFTER_BORROW_ACCOUNT_IS_NOT_SAFE\n );\n }\n```\n | 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[lastRequestId].depositRequestBalance[owner] = 0;\n _update(address(claimableSilo), receiver, shares);\n emit ClaimDeposit(lastRequestId, owner, receiver, assets, shares);\n}\n\nfunction previewClaimDeposit(address owner) public view returns (uint256) {\n uint256 lastRequestId = lastDepositRequestId[owner];\n uint256 assets = epochs[lastRequestId].depositRequestBalance[owner];\n return _convertToShares(assets, lastRequestId, Math.Rounding.Floor);\n}\n\nfunction _convertToShares(\n uint256 assets,\n uint256 requestId,\n Math.Rounding rounding\n)\n internal\n view\n returns (uint256)\n{\n if (isCurrentEpoch(requestId)) {\n return 0;\n }\n uint256 totalAssets =\n epochs[requestId].totalAssetsSnapshotForDeposit + 1;\n uint256 totalSupply =\n epochs[requestId].totalSupplySnapshotForDeposit + 1;\n\n return assets.mulDiv(totalSupply, totalAssets, rounding);\n}\n```\n | 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 freeMemoryPointer,\n 0xa9059cbb00000000000000000000000000000000000000000000000000000000\n ) // Begin with the function selector.\n mstore(\n add(freeMemoryPointer, 4),\n and(to, 0xffffffffffffffffffffffffffffffffffffffff)\n ) // Mask and append the "to" argument.\n mstore(add(freeMemoryPointer, 36), amount) // Finally append the "amount" argument. No mask as it's a full 32 byte value.\n\n // Call the token and store if it succeeded or not.\n // We use 68 because the calldata length is 4 + 32 * 2.\n callStatus := call(gas(), token, 0, freeMemoryPointer, 68, 0, 0)\n }\n\n require(\n didLastOptionalReturnCallSucceed(callStatus),\n "TRANSFER_FAILED"\n );\n}\n```\n | 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 : totalOwed\n);\n// write off only what we lost\ntotalBorrowed -= lostAmt;\n// set the account with the funds the pool lost\naccount.principal = lostAmt;\n\naccount.save(router, agentID, id);\n```\n | 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) / WAD;\n } else {\n // We get the current exchange rate and calculate the amount to be redeemed:\n // uTokenAmount = amountOut / exchangeRate\n // underlyingAmount = amountOut\n uTokenAmount = (amountOut * WAD) / exchangeRate;\n underlyingAmount = amountOut;\n }\n```\n | 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, "Transfer failed");\n}\n```\n | 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_;\n active = false;\n}\n```\n | 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 amount) public override returns (uint256) {\n ISushiBar bar = ISushiBar(sushiBar);\n ISushi sushi = ISushi(sushiAddr);\n\n uint256 totalShares = bar.totalSupply();\n uint256 barSushiBalance = sushi.balanceOf(address(bar));\n uint256 requiredShares = amount.mul(totalShares).div(barSushiBalance);\n\n uint256 barBeforeBalance = bar.balanceOf(address(this));\n uint256 sushiBeforeBalance = sushi.balanceOf(address(this));\n\n bar.leave(requiredShares);\n\n uint256 barAfterBalance = bar.balanceOf(address(this));\n uint256 sushiAfterBalance = sushi.balanceOf(address(this));\n\n uint256 barBalanceDiff = barBeforeBalance.sub(barAfterBalance);\n uint256 sushiBalanceDiff = sushiAfterBalance.sub(sushiBeforeBalance);\n\n balances[msg.sender] = balances[msg.sender].sub(barBalanceDiff);\n sushi.transfer(msg.sender, sushiBalanceDiff);\n return (sushiBalanceDiff);\n}\n```\n | 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);\n}\n```\n | 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();\n // interest accrued since last depositXX/withdrawXX/harvest is splitted between AA and BB\n // according to trancheAPRSplitRatio. NAVs of AA and BB are updated and tranche\n // prices adjusted accordingly\n \_updateAccounting();\n // mint tranche tokens according to the current tranche price\n \_minted = \_mintShares(\_amount, msg.sender, \_tranche);\n // get underlyings from sender\n IERC20Detailed(token).safeTransferFrom(msg.sender, address(this), \_amount);\n}\n```\n | 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 with optional penalty applied to their RPL deposit\n Setting // Change a DAO setting (Quorum threshold, RPL deposit size, voting periods etc)\n}\n```\n | 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 the leaf hash is in the Merkle tree; otherwise, False\n\*/\nfunction checkMembership(bytes32 leaf, uint256 index, bytes32 rootHash, bytes memory proof)\n internal\n pure\n returns (bool)\n{\n require(proof.length % 32 == 0, "Length of Merkle proof must be a multiple of 32");\n\n bytes32 proofElement;\n bytes32 computedHash = leaf;\n uint256 j = index;\n // Note: We're skipping the first 32 bytes of `proof`, which holds the size of the dynamically sized `bytes`\n for (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 % 2 == 0) {\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\n } else {\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\n }\n j = j / 2;\n }\n\n return computedHash == rootHash;\n}\n```\n | 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, _withoutSettlementFeeGlobal(self, assets));\n}\n\nfunction _toShares(Checkpoint memory self, UFixed6 assets) private pure returns (UFixed6) {\n UFixed6 selfAssets = UFixed6Lib.unsafeFrom(self.assets);\n return _withSpread(self, assets.muldiv(self.shares, selfAssets));\n}\n\nfunction _withSpread(Checkpoint memory self, UFixed6 amount) private pure returns (UFixed6) {\n UFixed6 selfAssets = UFixed6Lib.unsafeFrom(self.assets);\n UFixed6 totalAmount = self.deposit.add(self.redemption.muldiv(selfAssets, self.shares));\n UFixed6 totalAmountIncludingFee = UFixed6Lib.unsafeFrom(Fixed6Lib.from(totalAmount).sub(self.tradeFee));\n\n return totalAmount.isZero() ?\n amount :\n amount.muldiv(totalAmountIncludingFee, totalAmount);\n}\n\nfunction _withoutSettlementFeeGlobal(Checkpoint memory self, UFixed6 amount) private pure returns (UFixed6) {\n return _withoutSettlementFee(amount, self.settlementFee);\n}\n\nfunction _withoutSettlementFee(UFixed6 amount, UFixed6 settlementFee) private pure returns (UFixed6) {\n return amount.unsafeSub(settlementFee);\n}\n```\n | 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 uint128 expected = pool.sellBasePreview(a);\n\n // Verify slippage does not exceed the one set by the user\n if (expected < s) {\n revert Exception(16, expected, 0, address(0), address(0));\n }\n\n // Transfer the underlying tokens to the pool\n Safe.transferFrom(IERC20(pool.base()), msg.sender, address(pool), a);\n// rest of code\n function sellPrincipalToken(\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 // Preview amount of underlying received by selling `a` PTs\n uint256 expected = pool.sellFYTokenPreview(a);\n\n // Verify that the amount needed does not exceed the slippage parameter\n if (expected < s) {\n revert Exception(16, expected, s, address(0), address(0));\n }\n\n // Transfer the principal tokens to the pool\n Safe.transferFrom(\n IERC20(address(pool.fyToken())),\n msg.sender,\n address(pool),\n a\n );\n```\n | 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 signerFeeDivisor = \_signerFeeDivisor;\n emit SignerFeeDivisorUpdated(\_signerFeeDivisor);\n}\n```\n | 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.sol";\nimport "../contracts/token/WNT.sol";\nimport "../contracts/token/SOLToken.sol";\nimport "../contracts/token/USDC.sol";\nimport "../contracts/token/tokenA.sol";\nimport "../contracts/token/tokenB.sol";\nimport "../contracts/token/tokenC.sol";\n\nimport "../contracts/market/MarketFactory.sol";\nimport "../contracts/deposit/DepositUtils.sol";\nimport "../contracts/oracle/OracleUtils.sol";\nimport "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";\nimport "../contracts/withdrawal/WithdrawalUtils.sol";\nimport "../contracts/order/Order.sol";\nimport "../contracts/order/BaseOrderUtils.sol";\nimport "../contracts/price/Price.sol";\nimport "../contracts/utils/Debug.sol";\nimport "../contracts/position/Position.sol";\nimport "../contracts/exchange/LiquidationHandler.sol";\nimport "../contracts/utils/Calc.sol";\nimport "@openzeppelin/contracts/utils/math/SignedMath.sol";\nimport "@openzeppelin/contracts/utils/math/SafeCast.sol";\n\n\ncontract CounterTest is Test, Debug{\n using SignedMath for int256;\n using SafeCast for uint256;\n\n\n WNT _wnt; \n USDC _usdc;\n SOLToken _sol;\n tokenA _tokenA;\n tokenB _tokenB;\n tokenC _tokenC;\n\n RoleStore _roleStore;\n Router _router;\n DataStore _dataStore;\n EventEmitter _eventEmitter;\n DepositVault _depositVault;\n OracleStore _oracleStore; \n Oracle _oracle;\n DepositHandler _depositHandler;\n WithdrawalVault _withdrawalVault;\n WithdrawalHandler _withdrawalHandler;\n OrderHandler _orderHandler;\n SwapHandler _swapHandler;\n LiquidationHandler _liquidationHandler;\n ReferralStorage _referralStorage;\n OrderVault _orderVault;\n ExchangeRouter _erouter;\n MarketFactory _marketFactory;\n Market.Props _marketProps1;\n Market.Props _marketPropsAB;\n Market.Props _marketPropsBC;\n Market.Props _marketPropsCwnt;\n \n \n address depositor1;\n address depositor2;\n address depositor3;\n address uiFeeReceiver = address(333);\n\n\n function testGetFundingAmountPerSizeDelta() public{\n uint result = MarketUtils.getFundingAmountPerSizeDelta(2e15, 1e15+1, true);\n console2.log("result: %d", result);\n uint256 correctResult = 2e15 * 1e15 * 1e30 + 1e15; // this is a real round up\n correctResult = correctResult/(1e15+1);\n console2.log("correctResult: %d", correctResult);\n assertTrue(result == 1e15 * 1e30);\n }\n\n \n\n function setUp() public {\n _wnt = new WNT();\n _usdc = new USDC();\n _sol = new SOLToken();\n _tokenA = new tokenA();\n _tokenB = new tokenB();\n _tokenC = new tokenC();\n \n\n\n _roleStore = new RoleStore();\n _router = new Router(_roleStore);\n _dataStore = new DataStore(_roleStore);\n \n _eventEmitter= new EventEmitter(_roleStore);\n _depositVault = new DepositVault(_roleStore, _dataStore);\n _oracleStore = new OracleStore(_roleStore, _eventEmitter);\n _oracle = new Oracle(_roleStore, _oracleStore);\n console2.logString("_oracle:"); console2.logAddress(address(_oracle));\n \n _depositHandler = new DepositHandler(_roleStore, _dataStore, _eventEmitter, _depositVault, _oracle);\n console2.logString("_depositHandler:"); console2.logAddress(address(_depositHandler));\n \n\n _withdrawalVault = new WithdrawalVault(_roleStore, _dataStore);\n _withdrawalHandler = new WithdrawalHandler(_roleStore, _dataStore, _eventEmitter, _withdrawalVault, _oracle);\n \n \n _swapHandler = new SwapHandler(_roleStore);\n _orderVault = new OrderVault(_roleStore, _dataStore);\n _referralStorage = new ReferralStorage();\n\n\n \n _orderHandler = new OrderHandler(_roleStore, _dataStore, _eventEmitter, _orderVault, _oracle, _swapHandler, _referralStorage); \n _erouter = new ExchangeRouter(_router, _roleStore, _dataStore, _eventEmitter, _depositHandler, _withdrawalHandler, _orderHandler);\n console2.logString("_erouter:"); console2.logAddress(address(_erouter));\n _liquidationHandler = new LiquidationHandler(_roleStore, _dataStore, _eventEmitter, _orderVault, _oracle, _swapHandler, _referralStorage);\n \n _referralStorage.setHandler(address(_orderHandler), true); \n\n /* set myself as the controller so that I can set the address of WNT (wrapped native token contracdt) */\n _roleStore.grantRole(address(this), Role.CONTROLLER);\n _roleStore.grantRole(address(this), Role.MARKET_KEEPER);\n \n _dataStore.setUint(Keys.MAX_SWAP_PATH_LENGTH, 5); // at most 5 markets in the path\n \n _dataStore.setAddress(Keys.WNT, address(_wnt));\n\n /* set the token transfer gas limit for wnt as 3200 */\n _dataStore.setUint(Keys.tokenTransferGasLimit(address(_wnt)), 32000); \n _dataStore.setUint(Keys.tokenTransferGasLimit(address(_usdc)), 32000); \n \n\n /* create a market (SQL, WNT, ETH, USDC) */\n _marketFactory = new MarketFactory(_roleStore, _dataStore, _eventEmitter);\n console2.logString("_marketFactory:"); console2.logAddress(address(_marketFactory));\n _roleStore.grantRole(address(_marketFactory), Role.CONTROLLER); // to save a market's props\n _roleStore.grantRole(address(_erouter), Role.CONTROLLER); \n _roleStore.grantRole(address(_depositHandler), Role.CONTROLLER); \n _roleStore.grantRole(address(_withdrawalHandler), Role.CONTROLLER); \n _roleStore.grantRole(address(_swapHandler), Role.CONTROLLER);\n _roleStore.grantRole(address(_orderHandler), Role.CONTROLLER); \n _roleStore.grantRole(address(_liquidationHandler), Role.CONTROLLER); \n _roleStore.grantRole(address(_oracleStore), Role.CONTROLLER); // so it can call EventEmitter\n _roleStore.grantRole(address(_oracle), Role.CONTROLLER); // so it can call EventEmitter\n _roleStore.grantRole(address(this), Role.ORDER_KEEPER);\n _roleStore.grantRole(address(this), Role.LIQUIDATION_KEEPER);\n\n \n _marketProps1 = _marketFactory.createMarket(address(_sol), address(_wnt), address(_usdc), keccak256(abi.encode("sol-wnt-usdc"))); \n _marketPropsAB = _marketFactory.createMarket(address(0), address(_tokenA), address(_tokenB), keccak256(abi.encode("swap-tokenA-tokenB"))); \n _marketPropsBC = _marketFactory.createMarket(address(0), address(_tokenB), address(_tokenC), keccak256(abi.encode("swap-tokenB-tokenC"))); \n _marketPropsCwnt = _marketFactory.createMarket(address(0), address(_tokenC), address(_wnt), keccak256(abi.encode("swap-tokenC-wnt"))); \n \n \n _dataStore.setUint(Keys.minCollateralFactorForOpenInterestMultiplierKey(_marketProps1.marketToken, true), 1e25);\n _dataStore.setUint(Keys.minCollateralFactorForOpenInterestMultiplierKey(_marketProps1.marketToken, false), 1e25);\n \n // see fees for the market\n _dataStore.setUint(Keys.swapFeeFactorKey(_marketProps1.marketToken), 0.05e30); // 5%\n _dataStore.setUint(Keys.SWAP_FEE_RECEIVER_FACTOR, 0.5e30);\n _dataStore.setUint(Keys.positionFeeFactorKey(_marketProps1.marketToken), 0.00001234e30); // 2%\n _dataStore.setUint(Keys.POSITION_FEE_RECEIVER_FACTOR, 0.15e30);\n _dataStore.setUint(Keys.MAX_UI_FEE_FACTOR, 0.01e30);\n _dataStore.setUint(Keys.uiFeeFactorKey(uiFeeReceiver), 0.01e30); // only when this is set, one can receive ui fee, so stealing is not easy\n _dataStore.setInt(Keys.poolAmountAdjustmentKey(_marketProps1.marketToken, _marketProps1.longToken), 1);\n _dataStore.setInt(Keys.poolAmountAdjustmentKey(_marketProps1.marketToken, _marketProps1.shortToken), 1);\n _dataStore.setUint(Keys.swapImpactExponentFactorKey(_marketProps1.marketToken), 10e28);\n _dataStore.setUint(Keys.swapImpactFactorKey(_marketProps1.marketToken, true), 0.99e30);\n _dataStore.setUint(Keys.swapImpactFactorKey(_marketProps1.marketToken, false), 0.99e30);\n\n \n \n \n // set gas limit to transfer a token\n _dataStore.setUint(Keys.tokenTransferGasLimit(address(_sol)), 32000); \n _dataStore.setUint(Keys.tokenTransferGasLimit(address(_wnt)), 32000); \n _dataStore.setUint(Keys.tokenTransferGasLimit(address(_usdc)), 32000); \n _dataStore.setUint(Keys.tokenTransferGasLimit(address(_tokenA)), 32000); \n _dataStore.setUint(Keys.tokenTransferGasLimit(address(_tokenB)), 32000); \n _dataStore.setUint(Keys.tokenTransferGasLimit(address(_tokenC)), 32000); \n _dataStore.setUint(Keys.tokenTransferGasLimit(address(_marketProps1.marketToken)), 32000); \n _dataStore.setUint(Keys.tokenTransferGasLimit(address(_marketPropsAB.marketToken)), 32000);\n _dataStore.setUint(Keys.tokenTransferGasLimit(address(_marketPropsBC.marketToken)), 32000);\n _dataStore.setUint(Keys.tokenTransferGasLimit(address(_marketPropsCwnt.marketToken)), 32000);\n\n\n /* Configure the system parameters/limits here */\n _dataStore.setUint(Keys.MAX_CALLBACK_GAS_LIMIT, 10000);\n _dataStore.setUint(Keys.EXECUTION_GAS_FEE_BASE_AMOUNT, 100);\n _dataStore.setUint(Keys.MAX_ORACLE_PRICE_AGE, 2 hours);\n _dataStore.setUint(Keys.MIN_ORACLE_BLOCK_CONFIRMATIONS, 3);\n _dataStore.setUint(Keys.MIN_COLLATERAL_USD, 1e30); // just require $1 as min collateral usd\n _dataStore.setUint(Keys.reserveFactorKey(_marketProps1.marketToken, true), 5e29); // 50%\n _dataStore.setUint(Keys.reserveFactorKey(_marketProps1.marketToken, false), 5e29);\n _dataStore.setUint(Keys.fundingExponentFactorKey(_marketProps1.marketToken), 1.1e30); // 2 in 30 decimals like a square, cube, etc\n _dataStore.setUint(Keys.fundingFactorKey(_marketProps1.marketToken), 0.0000001e30);\n _dataStore.setUint(Keys.borrowingFactorKey(_marketProps1.marketToken, true), 0.87e30);\n _dataStore.setUint(Keys.borrowingFactorKey(_marketProps1.marketToken, false), 0.96e30);\n _dataStore.setUint(Keys.borrowingExponentFactorKey(_marketProps1.marketToken, true), 2.1e30);\n _dataStore.setUint(Keys.borrowingExponentFactorKey(_marketProps1.marketToken, false), 2.3e30);\n _dataStore.setUint(Keys.positionImpactExponentFactorKey(_marketProps1.marketToken), 2e30);\n _dataStore.setUint(Keys.positionImpactFactorKey(_marketProps1.marketToken, true), 5e22); \n _dataStore.setUint(Keys.positionImpactFactorKey(_marketProps1.marketToken, false), 1e23);\n\n // set the limit of market tokens\n\n _dataStore.setUint(Keys.maxPoolAmountKey(_marketProps1.marketToken, _marketProps1.longToken), 1000e18);\n _dataStore.setUint(Keys.maxPoolAmountKey(_marketProps1.marketToken, _marketProps1.shortToken), 1000e18);\n _dataStore.setUint(Keys.maxPoolAmountKey(_marketPropsAB.marketToken, _marketPropsAB.longToken), 1000e18);\n _dataStore.setUint(Keys.maxPoolAmountKey(_marketPropsAB.marketToken, _marketPropsAB.shortToken), 1000e18);\n _dataStore.setUint(Keys.maxPoolAmountKey(_marketPropsBC.marketToken, _marketPropsBC.longToken), 1000e18);\n _dataStore.setUint(Keys.maxPoolAmountKey(_marketPropsBC.marketToken, _marketPropsBC.shortToken), 1000e18);\n _dataStore.setUint(Keys.maxPoolAmountKey(_marketPropsCwnt.marketToken, _marketPropsCwnt.longToken), 1000e18);\n _dataStore.setUint(Keys.maxPoolAmountKey(_marketPropsCwnt.marketToken, _marketPropsCwnt.shortToken), 1000e18);\n \n \n // set max open interest for each market\n _dataStore.setUint(Keys.maxOpenInterestKey(_marketProps1.marketToken, true), 1e39); // 1B $ \n _dataStore.setUint(Keys.maxOpenInterestKey(_marketProps1.marketToken, false), 1e39); // 1B $\n\n _dataStore.setUint(Keys.maxPnlFactorKey(Keys.MAX_PNL_FACTOR_FOR_WITHDRAWALS, _marketProps1.marketToken, true), 10**29); // maxPnlFactor = 10% for long\n _dataStore.setUint(Keys.maxPnlFactorKey(Keys.MAX_PNL_FACTOR_FOR_WITHDRAWALS, _marketProps1.marketToken, false), 10**29); // maxPnlFactor = 10% for short\n // _dataStore.setBool(Keys.cancelDepositFeatureDisabledKey(address(_depositHandler)), true);\n _dataStore.setBool(Keys.cancelOrderFeatureDisabledKey(address(_orderHandler), uint256(Order.OrderType.MarketIncrease)), true);\n\n addFourSigners();\n address(_wnt).call{value: 10000e18}("");\n depositor1 = address(0x801);\n depositor2 = address(0x802);\n depositor3 = address(0x803);\n\n // make sure each depositor has some tokens.\n _wnt.transfer(depositor1, 1000e18);\n _wnt.transfer(depositor2, 1000e18);\n _wnt.transfer(depositor3, 1000e18); \n _usdc.transfer(depositor1, 1000e18);\n _usdc.transfer(depositor2, 1000e18);\n _usdc.transfer(depositor3, 1000e18);\n _tokenA.transfer(depositor1, 1000e18);\n _tokenB.transfer(depositor1, 1000e18);\n _tokenC.transfer(depositor1, 1000e18); \n\n printAllTokens(); \n }\n\n error Unauthorized(string);\n // error Error(string);\n\n\nfunction testLimit() public{\n OracleUtils.SetPricesParams memory priceParams = createSetPricesParams();\n \n vm.roll(block.number+2); // block 3\n\n \n bytes32 key = createDepositNoSwap(_marketProps1, depositor1, 90e18, true); // create a deposit at block 3 which is within range (2, 6) \n _depositHandler.executeDeposit(key, priceParams); \n uint mintedMarketTokens = IERC20(_marketProps1.marketToken).balanceOf(depositor1);\n key = createDepositNoSwap(_marketProps1, depositor1, 100e18, false); // create a deposit at block 3 which is within range (2, 6) \n _depositHandler.executeDeposit(key, priceParams); \n mintedMarketTokens = IERC20(_marketProps1.marketToken).balanceOf(depositor1);\n console2.log("Experiment 1 is completed."); \n \n // console2.log("PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP");\n \n key = createMarketSwapOrder(depositor1, address(_wnt), 1e15); // create a deposit at block 3 which is within range (2, 6) \n _orderHandler.executeOrder(key, priceParams); \n console2.log("Experiment 2 is completed."); \n \n\n console2.log("\n\n depositor 1 createMarketIncreaseOrder");\n key = createMarketIncreaseOrder(depositor1, _marketProps1.marketToken, _marketProps1.longToken, 20e18, 1001e30, 106000000000000, true); // \n console2.log("\nExecuting the order// rest of code");\n _orderHandler.executeOrder(key, priceParams);\n Position.printPosition(_dataStore, depositor1, _marketProps1.marketToken, _marketProps1.longToken, true);\n console2.log("Experiment 3 is completed."); \n \n \n\n console2.log("\n\n depositor 2 createMarketIncreaseOrder");\n key = createMarketIncreaseOrder(depositor2, _marketProps1.marketToken, _marketProps1.longToken, 110e18, 13e30, 101000000000000, false); // 110 usdc as collateral\n console2.log("\nExecuting the order// rest of code");\n _orderHandler.executeOrder(key, priceParams);\n Position.printPosition(_dataStore, depositor2, _marketProps1.marketToken, _marketProps1.longToken, false);\n console2.log("Experiment 4 is completed."); \n \n\n\n console2.log("PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP");\n vm.warp(2 days);\n setIndexTokenPrice(priceParams, 98, 100); // send 20e18 USDC, increase $13.123 in a long position with trigger price 101\n key = createLimitIncreaseOrder(depositor3, _marketProps1.marketToken, _marketProps1.shortToken, 23e18, 1.1234567e30, 101000000000000, true); // collateral token, usdsize, price\n console2.log("a LimitIncrease order created by depositor3 with key: ");\n console2.logBytes32(key);\n Position.printPosition(_dataStore, depositor3, _marketProps1.marketToken, _marketProps1.shortToken, true);\n console2.log("\n\nExecuting the order, exiting moment// rest of code\n\n");\n _orderHandler.executeOrder(key, priceParams);\n Position.printPosition(_dataStore, depositor3, _marketProps1.marketToken, _marketProps1.shortToken, true);\n console2.log("Experiment 5 is completed.\n"); \n \n\n // depositor3 creates a LimitDecrease order\n /*\n setIndexTokenPrice(priceParams, 120, 125);\n key = createLimitDecreaseOrder(depositor3, _marketProps1.marketToken, _marketProps1.shortToken, 7e18, 58e30, 120000000000000, 120000000000000, true); // retrieve $50? collateral token, usdsize, acceptible price\n console2.log("a LimitIncrease order created by depositor3 with key: ");\n console2.logBytes32(key);\n Position.printPosition(_dataStore, depositor3, _marketProps1.marketToken, _marketProps1.shortToken, true);\n console2.log("\n\nExecuting the order, exiting moment// rest of code\n\n");\n _orderHandler.executeOrder(key, priceParams); \n console2.log("Experiment 7 for is completed."); \n */\n}\n\nfunction testMarketDecrease() public{\n \n OracleUtils.SetPricesParams memory priceParams = createSetPricesParams();\n \n vm.roll(block.number+2); // block 3\n\n \n bytes32 key = createDepositNoSwap(_marketProps1, depositor1, 90e18, true); // create a deposit at block 3 which is within range (2, 6) \n _depositHandler.executeDeposit(key, priceParams); \n uint mintedMarketTokens = IERC20(_marketProps1.marketToken).balanceOf(depositor1);\n key = createDepositNoSwap(_marketProps1, depositor1, 100e18, false); // create a deposit at block 3 which is within range (2, 6) \n _depositHandler.executeDeposit(key, priceParams); \n mintedMarketTokens = IERC20(_marketProps1.marketToken).balanceOf(depositor1);\n console2.log("Experiment 1 is completed."); \n \n \n \n \n console2.log("\n\n depositor 2 deposit into marketProps1");\n key = createDepositNoSwap(_marketProps1, depositor2, 100e18, true);\n _depositHandler.executeDeposit(key, priceParams);\n mintedMarketTokens = IERC20(_marketProps1.marketToken).balanceOf(depositor2);\n printPoolsAmounts();\n console2.log("Experiment 2 is completed."); \n \n \n console2.log("\n\n depositor 1 createMarketIncreaseOrder");\n key = createMarketIncreaseOrder(depositor1, _marketProps1.marketToken, _marketProps1.longToken, 20e18, 1e25, 106000000000000, true); // \n console2.log("\nExecuting the order// rest of code");\n _orderHandler.executeOrder(key, priceParams);\n Position.printPosition(_dataStore, depositor1, _marketProps1.marketToken, _marketProps1.longToken, true);\n console2.log("Experiment 3 is completed."); \n \n \n\n console2.log("\n\n depositor 2 createMarketIncreaseOrder");\n key = createMarketIncreaseOrder(depositor2, _marketProps1.marketToken, _marketProps1.longToken, 110e18, 1e25, 101000000000000, false); // 110 usdc as collateral\n console2.log("\nExecuting the order// rest of code");\n _orderHandler.executeOrder(key, priceParams);\n Position.printPosition(_dataStore, depositor2, _marketProps1.marketToken, _marketProps1.longToken, false);\n console2.log("Experiment 4 is completed."); \n \n console2.log("********************************************");\n\n // deposit 2 will execute a marketDecreaseOrder now\n key = createMarketDecreaseOrder(depositor2, _marketProps1.marketToken, _marketProps1.longToken, 70000000000000, 5e23, false) ; // decrease by 5%\n console2.log("a market desced order created with key: ");\n console2.logBytes32(key);\n console2.log("\nExecuting the order// rest of code"); \n setIndexTokenPrice(priceParams, 60, 65); // we have a profit for a short position\n _orderHandler.executeOrder(key, priceParams);\n Position.printPosition(_dataStore, depositor2, _marketProps1.marketToken, _marketProps1.longToken, false);\n console2.log("Experiment 5 is completed."); \n\n printAllTokens();\n} \n\n \n\nfunction testLiquidation() public{\n // blockrange (2, 6)\n OracleUtils.SetPricesParams memory priceParams = createSetPricesParams();\n \n vm.roll(block.number+2); // block 3\n\n \n bytes32 key = createDepositNoSwap(_marketProps1, depositor1, 90e18, true); // create a deposit at block 3 which is within range (2, 6) \n _depositHandler.executeDeposit(key, priceParams); \n uint mintedMarketTokens = IERC20(_marketProps1.marketToken).balanceOf(depositor1);\n key = createDepositNoSwap(_marketProps1, depositor1, 100e18, false); // create a deposit at block 3 which is within range (2, 6) \n _depositHandler.executeDeposit(key, priceParams); \n mintedMarketTokens = IERC20(_marketProps1.marketToken).balanceOf(depositor1);\n console2.log("Experiment 1 is completed."); \n \n \n \n \n console2.log("\n\n depositor 2 deposit into marketProps1");\n key = createDepositNoSwap(_marketProps1, depositor2, 100e18, true);\n _depositHandler.executeDeposit(key, priceParams);\n mintedMarketTokens = IERC20(_marketProps1.marketToken).balanceOf(depositor2);\n printPoolsAmounts();\n console2.log("Experiment 2 is completed."); \n \n \n console2.log("\n\n depositor 1 createMarketIncreaseOrder");\n key = createMarketIncreaseOrder(depositor1, _marketProps1.marketToken, _marketProps1.longToken, 10e18, 1e25, 106000000000000, true);\n console2.log("\nExecuting the order// rest of code");\n _orderHandler.executeOrder(key, priceParams);\n Position.printPosition(_dataStore, depositor1, _marketProps1.marketToken, _marketProps1.longToken, true);\n console2.log("Experiment 3 is completed."); \n \n \n\n console2.log("\n\n depositor 2 createMarketIncreaseOrder");\n key = createMarketIncreaseOrder(depositor2, _marketProps1.marketToken, _marketProps1.shortToken, 100e18, 1e25, 101000000000000, false);\n console2.log("\nExecuting the order// rest of code");\n _orderHandler.executeOrder(key, priceParams);\n Position.printPosition(_dataStore, depositor2, _marketProps1.marketToken, _marketProps1.shortToken, false);\n console2.log("Experiment 4 is completed."); \n \n \n\n // deposit 2 will execute a marketDecreaseOrder now\n key = createMarketDecreaseOrder(depositor2, _marketProps1.marketToken, _marketProps1.shortToken, 106000000000000, 5e23, false) ; // decrease by 5%\n console2.log("a market desced order created with key: ");\n console2.logBytes32(key);\n console2.log("\nExecuting the order// rest of code"); \n setIndexTokenPrice(priceParams, 84, 90);\n _orderHandler.executeOrder(key, priceParams);\n Position.printPosition(_dataStore, depositor2, _marketProps1.marketToken, _marketProps1.shortToken, false);\n console2.log("Experiment 5 is completed."); \n \n \n\n \n // depositor3 will execute a LimitIncrease Order now\n key = createMarketIncreaseOrder(depositor3, _marketProps1.marketToken, _marketProps1.shortToken, 20e18, 200e30, 101000000000000, true); // collateral token, usdsize, price\n console2.log("a LimitIncrease order created by depositor3 with key: ");\n console2.logBytes32(key);\n Position.printPosition(_dataStore, depositor3, _marketProps1.marketToken, _marketProps1.shortToken, true);\n console2.log("\n\nExecuting the order, exiting moment// rest of code\n\n");\n _orderHandler.executeOrder(key, priceParams);\n Position.printPosition(_dataStore, depositor3, _marketProps1.marketToken, _marketProps1.shortToken, true);\n console2.log("Experiment 6 is completed.\n"); \n \n\n // depositor3 creates a LimitDecrease order\n setIndexTokenPrice(priceParams, 120, 125);\n key = createLimitDecreaseOrder(depositor3, _marketProps1.marketToken, _marketProps1.shortToken, 7e18, 58e30, 120000000000000, 120000000000000, true); // retrieve $50? collateral token, usdsize, acceptible price\n console2.log("a LimitIncrease order created by depositor3 with key: ");\n console2.logBytes32(key);\n Position.printPosition(_dataStore, depositor3, _marketProps1.marketToken, _marketProps1.shortToken, true);\n console2.log("\n\nExecuting the order, exiting moment// rest of code\n\n");\n _orderHandler.executeOrder(key, priceParams); \n console2.log("Experiment 7 for is completed."); \n \n // depositor3 creates a stopLossDecrease order\n setIndexTokenPrice(priceParams, 97, 99);\n key = createStopLossDecrease(depositor3, _marketProps1.marketToken, _marketProps1.shortToken, 7e18, 58e30, 95000000000000, 92000000000000, true); // retrieve $50? collateral token, usdsize, acceptible price\n console2.log("a StopLossDecrease order created by depositor3 with key: ");\n console2.logBytes32(key);\n // Position.printPosition(_dataStore, depositor3, _marketProps1.marketToken, _marketProps1.shortToken, true);\n\n console2.log("\n\nExecuting the order, exiting moment// rest of code\n\n");\n _orderHandler.executeOrder(key, priceParams);\n console2.log("Experiment 8 is completed."); \n \n \n console2.log("\n\n*************************************************\n\n");\n\n\n // depositor3 creates a Liquidation order\n setIndexTokenPrice(priceParams, 75, 75);\n console2.log("Liquidate a position// rest of code");\n Position.printPosition(_dataStore, depositor3, _marketProps1.marketToken, _marketProps1.shortToken, true);\n _liquidationHandler.executeLiquidation(depositor3, _marketProps1.marketToken, _marketProps1.shortToken, true, priceParams);\n console2.log("Experiment 9 is completed."); \n \n\n // printPoolsAmounts();\n printAllTokens();\n\n \n \n \n}\n\nfunction printAllTokens() startedCompleted("printAllTokens") public\n{\n console2.log("\nTokens used in this test:");\n console2.log("_wnt: "); console2.logAddress(address(_wnt));\n console2.log("_usdc: "); console2.logAddress(address(_usdc));\n console2.log("_sol: "); console2.logAddress(address(_sol));\n console2.log("_tokenA: "); console2.logAddress(address(_tokenA));\n console2.log("_tokenB: "); console2.logAddress(address(_tokenB));\n console2.log("_tokenC: "); console2.logAddress(address(_tokenC));\n console2.logString("test contract address:"); console2.logAddress(address(this));\n \n console2.log("_marketProps1 market token: "); console2.logAddress(address(_marketProps1.marketToken));\n console2.log("_marketPropsAB market token: "); console2.logAddress(address(_marketPropsAB.marketToken));\n console2.log("_marketPropsBC market token: "); console2.logAddress(address(_marketPropsBC.marketToken));\n console2.log("_marketProps1Cwnt market token: "); console2.logAddress(address(_marketPropsCwnt.marketToken));\n console2.log("\n");\n \n \n}\n\n\nfunction printMarketTokenAmount() public \n{ console2.log("Market token address: ");\n console2.logAddress(address(_marketProps1.marketToken));\n console2.log("depositor1 market token amount: %d", IERC20(_marketProps1.marketToken).balanceOf(depositor1));\n console2.log("depositor2 market token amount: %d", IERC20(_marketProps1.marketToken).balanceOf(depositor2));\n console2.log("depositor3 market token amount: %d", IERC20(_marketProps1.marketToken).balanceOf(depositor3));\n}\n\nfunction printLongShortTokens(address account) public\n{\n console2.log("balance for "); console2.logAddress(account);\n console2.log("_wnt balance:", _wnt.balanceOf(account));\n console2.log("usdc balance:", _usdc.balanceOf(account));\n}\n\n\n\n\nfunction addFourSigners() private {\n _oracleStore.addSigner(address(901));\n _oracleStore.addSigner(address(902)); \n _oracleStore.addSigner(address(903)); \n _oracleStore.addSigner(address(904)); \n}\n\n\nfunction setIndexTokenPrice(OracleUtils.SetPricesParams memory priceParams, uint256 minP, uint256 maxP) public\n{\n uint256 mask1 = ~uint256(type(uint96).max); // (32*3 of 1's)\n console2.logBytes32(bytes32(mask1));\n\n uint256 minPrice = minP;\n minPrice = minPrice << 32 | minP;\n minPrice = minPrice << 32 | minP;\n\n uint256 maxPrice = maxP;\n maxPrice = maxPrice << 32 | maxP;\n maxPrice = maxPrice << 32 | maxP;\n\n priceParams.compactedMinPrices[0] = (priceParams.compactedMinPrices[0] & mask1) | minPrice;\n priceParams.compactedMaxPrices[0] = (priceParams.compactedMaxPrices[0] & mask1) | maxPrice;\n}\n\n\nfunction createSetPricesParams() public returns (OracleUtils.SetPricesParams memory) {\n uint256 signerInfo = 3; // signer 904\n signerInfo = signerInfo << 16 | 2; // signer 903\n signerInfo = signerInfo << 16 | 1; // signer 902\n signerInfo = signerInfo << 16 | 3; // number of singers\n // will read out as 902, 903, 904 from the lowest first\n\n // the number of tokens, 6\n address[] memory tokens = new address[](6);\n tokens[0] = address(_sol);\n tokens[1] = address(_wnt);\n tokens[2] = address(_usdc);\n tokens[3] = address(_tokenA);\n tokens[4] = address(_tokenB);\n tokens[5] = address(_tokenC);\n\n // must be equal to the number of tokens 6, 64 for each one, so 64*6. 64*4 for one element, so need two elements \n uint256[] memory compactedMinOracleBlockNumbers = new uint256[](2);\n compactedMinOracleBlockNumbers[0] = block.number+1;\n compactedMinOracleBlockNumbers[0] = compactedMinOracleBlockNumbers[0] << 64 | block.number+1;\n compactedMinOracleBlockNumbers[0] = compactedMinOracleBlockNumbers[0] << 64 | block.number+1;\n compactedMinOracleBlockNumbers[0] = compactedMinOracleBlockNumbers[0] << 64 | block.number+1;\n\n compactedMinOracleBlockNumbers[1] = block.number+1;\n compactedMinOracleBlockNumbers[1] = compactedMinOracleBlockNumbers[0] << 64 | block.number+1;\n \n // must be equal to the number of tokens 6, 64 for each one, so 64*6. 64*4 for one element, so need two elements \n \n uint256[] memory compactedMaxOracleBlockNumbers = new uint256[](2);\n compactedMaxOracleBlockNumbers[0] = block.number+5; \n compactedMaxOracleBlockNumbers[0] = compactedMaxOracleBlockNumbers[0] << 64 | block.number+5;\n compactedMaxOracleBlockNumbers[0] = compactedMaxOracleBlockNumbers[0] << 64 | block.number+5; \n compactedMaxOracleBlockNumbers[0] = compactedMaxOracleBlockNumbers[0] << 64 | block.number+5; \n\n compactedMaxOracleBlockNumbers[1] = block.number+5; \n compactedMaxOracleBlockNumbers[1] = compactedMaxOracleBlockNumbers[0] << 64 | block.number+5;\n\n // must be equal to the number of tokens 6, 64 for each one, so 64*6. 64*4 for one element, so need two elements \n uint256[] memory compactedOracleTimestamps = new uint256[](2);\n compactedOracleTimestamps[0] = 9;\n compactedOracleTimestamps[0] = compactedOracleTimestamps[0] << 64 | 8;\n compactedOracleTimestamps[0] = compactedOracleTimestamps[0] << 64 | 7;\n compactedOracleTimestamps[0] = compactedOracleTimestamps[0] << 64 | 7;\n \n compactedOracleTimestamps[1] = 9;\n compactedOracleTimestamps[1] = compactedOracleTimestamps[0] << 64 | 8;\n \n\n // must be equal to the number of tokens, 8 for each, so 8*6= 48, only need one element\n uint256[] memory compactedDecimals = new uint256[](1);\n compactedDecimals[0] = 12;\n compactedDecimals[0] = compactedDecimals[0] << 8 | 12;\n compactedDecimals[0] = compactedDecimals[0] << 8 | 12;\n compactedDecimals[0] = compactedDecimals[0] << 8 | 12;\n compactedDecimals[0] = compactedDecimals[0] << 8 | 12;\n compactedDecimals[0] = compactedDecimals[0] << 8 | 12;\n \n \n // three signers, 6 tokens, so we have 3*6 = 18 entries, each entry takes 32 bits, so each 8 entries takes one element, we need 3 elements\n // price table:\n // SOL: 100 101 102\n // wnt: 200 201 203\n // USDC 1 1 1\n // tokenA 100 101 102\n // tokenB 200 202 204\n // tokenC 400 404 408\n\n uint256[] memory compactedMinPrices = new uint256[](3);\n compactedMinPrices[2] = 408; \n compactedMinPrices[2] = compactedMinPrices[2] << 32 | 404;\n\n compactedMinPrices[1] = 400;\n compactedMinPrices[1] = compactedMinPrices[1] << 32 | 204;\n compactedMinPrices[1] = compactedMinPrices[1] << 32 | 202;\n compactedMinPrices[1] = compactedMinPrices[1] << 32 | 200;\n compactedMinPrices[1] = compactedMinPrices[1] << 32 | 102;\n compactedMinPrices[1] = compactedMinPrices[1] << 32 | 101;\n compactedMinPrices[1] = compactedMinPrices[1] << 32 | 100;\n compactedMinPrices[1] = compactedMinPrices[1] << 32 | 1;\n \n compactedMinPrices[0] = 1;\n compactedMinPrices[0] = compactedMinPrices[0] << 32 | 1;\n compactedMinPrices[0] = compactedMinPrices[0] << 32 | 203;\n compactedMinPrices[0] = compactedMinPrices[0] << 32 | 201;\n compactedMinPrices[0] = compactedMinPrices[0] << 32 | 200;\n compactedMinPrices[0] = compactedMinPrices[0] << 32 | 102;\n compactedMinPrices[0] = compactedMinPrices[0] << 32 | 101;\n compactedMinPrices[0] = compactedMinPrices[0] << 32 | 100;\n \n // three signers, 6 tokens, so we have 3*6 = 18 entries, each entry takes 8 bits, so we just need one element\n\n uint256[] memory compactedMinPricesIndexes = new uint256[](1);\n compactedMinPricesIndexes[0] = 1;\n compactedMinPricesIndexes[0] = compactedMinPricesIndexes[0] << 8 | 2;\n compactedMinPricesIndexes[0] = compactedMinPricesIndexes[0] << 8 | 0;\n compactedMinPricesIndexes[0] = compactedMinPricesIndexes[0] << 8 | 1;\n compactedMinPricesIndexes[0] = compactedMinPricesIndexes[0] << 8 | 2;\n compactedMinPricesIndexes[0] = compactedMinPricesIndexes[0] << 8 | 0;\n compactedMinPricesIndexes[0] = compactedMinPricesIndexes[0] << 8 | 1;\n compactedMinPricesIndexes[0] = compactedMinPricesIndexes[0] << 8 | 2;\n compactedMinPricesIndexes[0] = compactedMinPricesIndexes[0] << 8 | 0; \n compactedMinPricesIndexes[0] = compactedMinPricesIndexes[0] << 8 | 1;\n compactedMinPricesIndexes[0] = compactedMinPricesIndexes[0] << 8 | 2;\n compactedMinPricesIndexes[0] = compactedMinPricesIndexes[0] << 8 | 0; \n compactedMinPricesIndexes[0] = compactedMinPricesIndexes[0] << 8 | 1;\n compactedMinPricesIndexes[0] = compactedMinPricesIndexes[0] << 8 | 2;\n compactedMinPricesIndexes[0] = compactedMinPricesIndexes[0] << 8 | 0; \n compactedMinPricesIndexes[0] = compactedMinPricesIndexes[0] << 8 | 1;\n compactedMinPricesIndexes[0] = compactedMinPricesIndexes[0] << 8 | 2;\n compactedMinPricesIndexes[0] = compactedMinPricesIndexes[0] << 8 | 0; \n \n // three signers, 6 tokens, so we have 3*6 = 18 entries, each entry takes 32 bits, so each 8 entries takes one element, we need 3 elements\n // price table:\n // SOL: 105 106 107\n // wnt: 205 206 208\n // USDC 1 1 1\n // tokenA 105 106 107\n // tokenB 205 207 209\n // tokenC 405 409 413\n uint256[] memory compactedMaxPrices = new uint256[](3);\n compactedMaxPrices[2] = 413;\n compactedMaxPrices[2] = compactedMaxPrices[2] << 32 | 409;\n \n compactedMaxPrices[1] = 405;\n compactedMaxPrices[1] = compactedMaxPrices[1] << 32 | 209;\n compactedMaxPrices[1] = compactedMaxPrices[1] << 32 | 207;\n compactedMaxPrices[1] = compactedMaxPrices[1] << 32 | 205;\n compactedMaxPrices[1] = compactedMaxPrices[1] << 32 | 107;\n compactedMaxPrices[1] = compactedMaxPrices[1] << 32 | 106;\n compactedMaxPrices[1] = compactedMaxPrices[1] << 32 | 105;\n compactedMaxPrices[1] = compactedMaxPrices[1] << 32 | 1;\n\n compactedMaxPrices[0] = 1;\n compactedMaxPrices[0] = compactedMaxPrices[0] << 32 | 1;\n compactedMaxPrices[0] = compactedMaxPrices[0] << 32 | 208;\n compactedMaxPrices[0] = compactedMaxPrices[0] << 32 | 206; \n compactedMaxPrices[0] = compactedMaxPrices[0] << 32 | 205; \n compactedMaxPrices[0] = compactedMaxPrices[0] << 32 | 107;\n compactedMaxPrices[0] = compactedMaxPrices[0] << 32 | 106;\n compactedMaxPrices[0] = compactedMaxPrices[0] << 32 | 105;\n \n \n // three signers, 6 tokens, so we have 3*6 = 18 entries, each entry takes 8 bits, so we just need one element\n\n uint256[] memory compactedMaxPricesIndexes = new uint256[](1);\n compactedMaxPricesIndexes[0] = 1; \n compactedMaxPricesIndexes[0] = compactedMaxPricesIndexes[0] << 8 | 2;\n compactedMaxPricesIndexes[0] = compactedMaxPricesIndexes[0] << 8 | 0;\n compactedMaxPricesIndexes[0] = compactedMaxPricesIndexes[0] << 8 | 1;\n compactedMaxPricesIndexes[0] = compactedMaxPricesIndexes[0] << 8 | 2;\n compactedMaxPricesIndexes[0] = compactedMaxPricesIndexes[0] << 8 | 0;\n compactedMaxPricesIndexes[0] = compactedMaxPricesIndexes[0] << 8 | 1;\n compactedMaxPricesIndexes[0] = compactedMaxPricesIndexes[0] << 8 | 2;\n compactedMaxPricesIndexes[0] = compactedMaxPricesIndexes[0] << 8 | 0;\n compactedMaxPricesIndexes[0] = compactedMaxPricesIndexes[0] << 8 | 1;\n compactedMaxPricesIndexes[0] = compactedMaxPricesIndexes[0] << 8 | 2;\n compactedMaxPricesIndexes[0] = compactedMaxPricesIndexes[0] << 8 | 0;\n compactedMaxPricesIndexes[0] = compactedMaxPricesIndexes[0] << 8 | 1;\n compactedMaxPricesIndexes[0] = compactedMaxPricesIndexes[0] << 8 | 2;\n compactedMaxPricesIndexes[0] = compactedMaxPricesIndexes[0] << 8 | 0;\n compactedMaxPricesIndexes[0] = compactedMaxPricesIndexes[0] << 8 | 1;\n compactedMaxPricesIndexes[0] = compactedMaxPricesIndexes[0] << 8 | 2;\n compactedMaxPricesIndexes[0] = compactedMaxPricesIndexes[0] << 8 | 0;\n \n // 3 signers and 6 tokens, so we need 3*6 signatures\n bytes[] memory signatures = new bytes[](18);\n for(uint i; i<18; i++){\n signatures[i] = abi.encode("SIGNATURE");\n }\n address[] memory priceFeedTokens;\n\n OracleUtils.SetPricesParams memory priceParams = OracleUtils.SetPricesParams(\n signerInfo,\n tokens,\n compactedMinOracleBlockNumbers,\n compactedMaxOracleBlockNumbers,\n compactedOracleTimestamps,\n compactedDecimals,\n compactedMinPrices, \n compactedMinPricesIndexes,\n compactedMaxPrices, \n compactedMaxPricesIndexes, \n signatures, \n priceFeedTokens\n );\n return priceParams;\n}\n\n/* \n* The current index token price (85, 90), a trader sets a trigger price to 100 and then acceptabiel price to 95.\n* He like to long the index token. \n* 1. Pick the primary price 90 since we long, so choose the max\n* 2. Make sure 90 < 100, and pick (90, 100) as the custom price since we long\n* 3. Choose price 95 since 95 is within the range, and it is the highest acceptible price. Choosing 90 \n* will be in favor of the trader\n* \n*/\n\nfunction createMarketSwapOrder(address account, address inputToken, uint256 inAmount) public returns(bytes32)\n{ \n address[] memory swapPath = new address[](1);\n swapPath[0] = _marketProps1.marketToken;\n // swapPath[0] = _marketPropsAB.marketToken;\n // swapPath[1] = _marketPropsBC.marketToken;\n // swapPath[2] = _marketPropsCwnt.marketToken;\n\n \n vm.prank(account); \n _wnt.transfer(address(_orderVault), 3200); // execution fee\n\n\n BaseOrderUtils.CreateOrderParams memory params;\n params.addresses.receiver = account; // the account is the receiver\n params.addresses.callbackContract = address(0);\n params.addresses.uiFeeReceiver = account; // set myself as the ui receiver\n // params.addresses.market = marketToken;\n params.addresses.initialCollateralToken = inputToken; // initial token\n params.addresses.swapPath = swapPath;\n\n // params.numbers.sizeDeltaUsd = sizeDeltaUsd;\n params.numbers.initialCollateralDeltaAmount = inAmount ; // this is actually useless, will be overidden by real transfer amount\n vm.prank(account); \n IERC20(inputToken).transfer(address(_orderVault), inAmount); // this is the real amount\n\n\n // params.numbers.triggerPrice = triggerPrice;\n // params.numbers.acceptablePrice = acceptablePrice; // I can buy with this price or lower effective spread control \n params.numbers.executionFee = 3200;\n params.numbers.callbackGasLimit = 3200;\n // params.numbers.initialCollateralDeltaAmount = inAmount;\n params.numbers.minOutputAmount = 100; // use the control the final collateral amount, not for the position size delta, which is indirectly controlled by acceptable price\n\n params.orderType = Order.OrderType.MarketSwap;\n params.decreasePositionSwapType = Order.DecreasePositionSwapType.NoSwap;\n // params.isLong = isLong;\n params.shouldUnwrapNativeToken = false;\n params.referralCode = keccak256(abi.encode("MY REFERRAL"));\n\n vm.prank(account);\n bytes32 key = _erouter.createOrder(params);\n return key;\n}\n\n\n\nfunction createLiquidationOrder(address account, address marketToken, address collateralToken, uint256 collateralAmount, uint sizeDeltaUsd, uint triggerPrice, uint256 acceptablePrice, bool isLong) public returns(bytes32)\n{\n address[] memory swapPath;\n \n //address[] memory swapPath = new address[](3);\n //swapPath[0] = _marketPropsAB.marketToken;\n //swapPath[1] = _marketPropsBC.marketToken;\n //swapPath[2] = _marketPropsCwnt.marketToken;\n\n \n vm.prank(account); \n _wnt.transfer(address(_orderVault), 3200); // execution fee\n\n\n BaseOrderUtils.CreateOrderParams memory params;\n params.addresses.receiver = account;\n params.addresses.callbackContract = address(0);\n params.addresses.uiFeeReceiver = uiFeeReceiver;\n params.addresses.market = marketToken; // final market\n params.addresses.initialCollateralToken = collateralToken; // initial token\n params.addresses.swapPath = swapPath;\n\n params.numbers.sizeDeltaUsd = sizeDeltaUsd;\n // params.numbers.initialCollateralDeltaAmount = ; // this is actually useless, will be overidden by real transfer amount\n vm.prank(account); \n IERC20(collateralToken).transfer(address(_orderVault), collateralAmount); // this is the real amount\n\n\n params.numbers.triggerPrice = triggerPrice;\n params.numbers.acceptablePrice = acceptablePrice; // I can buy with this price or lower effective spread control \n params.numbers.executionFee = 3200;\n params.numbers.callbackGasLimit = 3200;\n params.numbers.minOutputAmount = 100; // use the control the final collateral amount, not for the position size delta, which is indirectly controlled by acceptable price\n\n params.orderType = Order.OrderType.Liquidation;\n params.decreasePositionSwapType = Order.DecreasePositionSwapType.NoSwap;\n params.isLong = isLong;\n params.shouldUnwrapNativeToken = false;\n params.referralCode = keccak256(abi.encode("MY REFERRAL"));\n\n vm.prank(account);\n bytes32 key = _erouter.createOrder(params);\n return key;\n} \n\n\n\nfunction createStopLossDecrease(address account, address marketToken, address collateralToken, uint256 collateralAmount, uint sizeDeltaUsd, uint triggerPrice, uint256 acceptablePrice, bool isLong) public returns(bytes32)\n{\n address[] memory swapPath;\n \n //address[] memory swapPath = new address[](3);\n //swapPath[0] = _marketPropsAB.marketToken;\n //swapPath[1] = _marketPropsBC.marketToken;\n //swapPath[2] = _marketPropsCwnt.marketToken;\n\n \n vm.prank(account); \n _wnt.transfer(address(_orderVault), 3200); // execution fee\n\n\n BaseOrderUtils.CreateOrderParams memory params;\n params.addresses.receiver = account;\n params.addresses.callbackContract = address(0);\n params.addresses.uiFeeReceiver = uiFeeReceiver;\n params.addresses.market = marketToken; // final market\n params.addresses.initialCollateralToken = collateralToken; // initial token\n params.addresses.swapPath = swapPath;\n\n params.numbers.sizeDeltaUsd = sizeDeltaUsd;\n // params.numbers.initialCollateralDeltaAmount = ; // this is actually useless, will be overidden by real transfer amount\n vm.prank(account); \n IERC20(collateralToken).transfer(address(_orderVault), collateralAmount); // this is the real amount\n\n\n params.numbers.triggerPrice = triggerPrice;\n params.numbers.acceptablePrice = acceptablePrice; // I can buy with this price or lower effective spread control \n params.numbers.executionFee = 3200;\n params.numbers.callbackGasLimit = 3200;\n params.numbers.minOutputAmount = 100; // use the control the final collateral amount, not for the position size delta, which is indirectly controlled by acceptable price\n\n params.orderType = Order.OrderType.StopLossDecrease;\n params.decreasePositionSwapType = Order.DecreasePositionSwapType.NoSwap;\n params.isLong = isLong;\n params.shouldUnwrapNativeToken = false;\n params.referralCode = keccak256(abi.encode("MY REFERRAL"));\n\n vm.prank(account);\n bytes32 key = _erouter.createOrder(params);\n return key;\n} \n\n\n\nfunction createLimitDecreaseOrder(address account, address marketToken, address collateralToken, uint256 collateralAmount, uint sizeDeltaUsd, uint triggerPrice, uint256 acceptablePrice, bool isLong) public returns(bytes32)\n{\n address[] memory swapPath;\n \n //address[] memory swapPath = new address[](3);\n //swapPath[0] = _marketPropsAB.marketToken;\n //swapPath[1] = _marketPropsBC.marketToken;\n //swapPath[2] = _marketPropsCwnt.marketToken;\n\n \n vm.prank(account); \n _wnt.transfer(address(_orderVault), 3200); // execution fee\n\n\n BaseOrderUtils.CreateOrderParams memory params;\n params.addresses.receiver = account;\n params.addresses.callbackContract = address(0);\n params.addresses.uiFeeReceiver = uiFeeReceiver;\n params.addresses.market = marketToken; // final market\n params.addresses.initialCollateralToken = collateralToken; // initial token\n params.addresses.swapPath = swapPath;\n\n params.numbers.sizeDeltaUsd = sizeDeltaUsd;\n // params.numbers.initialCollateralDeltaAmount = ; // this is actually useless, will be overidden by real transfer amount\n vm.prank(account); \n IERC20(collateralToken).transfer(address(_orderVault), collateralAmount); // this is the real amount\n\n\n params.numbers.triggerPrice = triggerPrice;\n params.numbers.acceptablePrice = acceptablePrice; // I can buy with this price or lower effective spread control \n params.numbers.executionFee = 3200;\n params.numbers.callbackGasLimit = 3200;\n params.numbers.minOutputAmount = 100; // use the control the final collateral amount, not for the position size delta, which is indirectly controlled by acceptable price\n\n params.orderType = Order.OrderType.LimitDecrease;\n params.decreasePositionSwapType = Order.DecreasePositionSwapType.NoSwap;\n params.isLong = isLong;\n params.shouldUnwrapNativeToken = false;\n params.referralCode = keccak256(abi.encode("MY REFERRAL"));\n\n vm.prank(account);\n bytes32 key = _erouter.createOrder(params);\n return key;\n} \n\n\nfunction createLimitIncreaseOrder(address account, address marketToken, address collateralToken, uint256 collateralAmount, uint sizeDeltaUsd, uint triggerPrice, bool isLong) public returns(bytes32)\n{\n address[] memory swapPath;\n \n //address[] memory swapPath = new address[](3);\n //swapPath[0] = _marketPropsAB.marketToken;\n //swapPath[1] = _marketPropsBC.marketToken;\n //swapPath[2] = _marketPropsCwnt.marketToken;\n\n \n vm.prank(account); \n _wnt.transfer(address(_orderVault), 3200); // execution fee\n\n\n BaseOrderUtils.CreateOrderParams memory params;\n params.addresses.receiver = account;\n params.addresses.callbackContract = address(0);\n params.addresses.uiFeeReceiver = uiFeeReceiver;\n params.addresses.market = marketToken; // final market\n params.addresses.initialCollateralToken = collateralToken; // initial token\n params.addresses.swapPath = swapPath;\n\n params.numbers.sizeDeltaUsd = sizeDeltaUsd;\n // params.numbers.initialCollateralDeltaAmount = ; // this is actually useless, will be overidden by real transfer amount\n vm.prank(account); \n IERC20(collateralToken).transfer(address(_orderVault), collateralAmount); // this is the real amount\n\n\n params.numbers.triggerPrice = triggerPrice; // used for limit order\n params.numbers.acceptablePrice = 121000000000000; // I can buy with this price or lower effective spread control \n params.numbers.executionFee = 3200;\n params.numbers.callbackGasLimit = 3200;\n params.numbers.minOutputAmount = 100; // use the control the final collateral amount, not for the position size delta, which is indirectly controlled by acceptable price\n\n params.orderType = Order.OrderType.LimitIncrease;\n params.decreasePositionSwapType = Order.DecreasePositionSwapType.NoSwap;\n params.isLong = isLong;\n params.shouldUnwrapNativeToken = false;\n params.referralCode = keccak256(abi.encode("MY REFERRAL"));\n\n vm.prank(account);\n bytes32 key = _erouter.createOrder(params);\n return key;\n} \n\n\n\n\nfunction createMarketDecreaseOrder(address account, address marketToken, address collateralToken, uint256 acceptablePrice, uint256 sizeInUsd, bool isLong) public returns(bytes32)\n{\n address[] memory swapPath;\n \n //address[] memory swapPath = new address[](3);\n //swapPath[0] = _marketPropsAB.marketToken;\n //swapPath[1] = _marketPropsBC.marketToken;\n //swapPath[2] = _marketPropsCwnt.marketToken;\n\n \n vm.prank(account); \n _wnt.transfer(address(_orderVault), 3200); // execution fee\n\n\n BaseOrderUtils.CreateOrderParams memory params;\n params.addresses.receiver = account;\n params.addresses.callbackContract = address(0);\n params.addresses.uiFeeReceiver = uiFeeReceiver;\n params.addresses.market = marketToken; // final market\n params.addresses.initialCollateralToken = collateralToken; // initial token\n params.addresses.swapPath = swapPath;\n\n params.numbers.sizeDeltaUsd = sizeInUsd; // how much dollar to decrease, will convert into amt of tokens to decrease in long/short based on the execution price\n params.numbers.initialCollateralDeltaAmount = 13e18; // this is actually useless, will be overidden by real transfer amount\n // vm.prank(account); \n // IERC20(collateralToken).transfer(address(_orderVault), collateralAmount); // this is the real amount\n\n\n params.numbers.triggerPrice = 0;\n params.numbers.acceptablePrice = acceptablePrice; // I can buy with this price or lower effective spread control \n params.numbers.executionFee = 3200;\n params.numbers.callbackGasLimit = 3200;\n params.numbers.minOutputAmount = 10e18; // use the control the final collateral amount, not for the position size delta, which is indirectly controlled by acceptable price\n\n params.orderType = Order.OrderType.MarketDecrease;\n params.decreasePositionSwapType = Order.DecreasePositionSwapType.NoSwap;\n params.isLong = isLong;\n params.shouldUnwrapNativeToken = false;\n params.referralCode = keccak256(abi.encode("MY REFERRAL"));\n\n vm.prank(account);\n bytes32 key = _erouter.createOrder(params);\n return key;\n} \n\n\n\nfunction createMarketIncreaseOrder(address account, address marketToken, address collateralToken, uint256 collateralAmount, uint sizeDeltaUsd, uint acceptablePrice, bool isLong) public returns(bytes32)\n{\n address[] memory swapPath;\n \n //address[] memory swapPath = new address[](3);\n //swapPath[0] = _marketPropsAB.marketToken;\n //swapPath[1] = _marketPropsBC.marketToken;\n //swapPath[2] = _marketPropsCwnt.marketToken;\n\n \n vm.prank(account); \n _wnt.transfer(address(_orderVault), 3200); // execution fee\n\n\n BaseOrderUtils.CreateOrderParams memory params;\n params.addresses.receiver = account;\n params.addresses.callbackContract = address(0);\n params.addresses.uiFeeReceiver = uiFeeReceiver;\n params.addresses.market = marketToken; // final market\n params.addresses.initialCollateralToken = collateralToken; // initial token\n params.addresses.swapPath = swapPath;\n\n params.numbers.sizeDeltaUsd = sizeDeltaUsd;\n // params.numbers.initialCollateralDeltaAmount = ; // this is actually useless, will be overidden by real transfer amount\n vm.prank(account); \n IERC20(collateralToken).transfer(address(_orderVault), collateralAmount); // this is the real amount\n\n\n params.numbers.triggerPrice = 0;\n params.numbers.acceptablePrice = acceptablePrice; // I can buy with this price or lower effective spread control \n params.numbers.executionFee = 3200;\n params.numbers.callbackGasLimit = 3200;\n params.numbers.minOutputAmount = 100; // use the control the final collateral amount, not for the position size delta, which is indirectly controlled by acceptable price\n\n params.orderType = Order.OrderType.MarketIncrease;\n params.decreasePositionSwapType = Order.DecreasePositionSwapType.NoSwap;\n params.isLong = isLong;\n params.shouldUnwrapNativeToken = false;\n params.referralCode = keccak256(abi.encode("MY REFERRAL"));\n\n vm.prank(account);\n bytes32 key = _erouter.createOrder(params);\n return key;\n} \n\n\n\nfunction createWithdraw(address withdrawor, uint marketTokenAmount) public returns (bytes32)\n{\n address[] memory longTokenSwapPath;\n address[] memory shortTokenSwapPath;\n\n console.log("createWithdraw with withdrawor: ");\n console.logAddress(withdrawor);\n vm.prank(withdrawor); \n _wnt.transfer(address(_withdrawalVault), 3200); // execution fee\n\n vm.prank(withdrawor);\n ERC20(_marketProps1.marketToken).transfer(address(_withdrawalVault), marketTokenAmount);\n\n WithdrawalUtils.CreateWithdrawalParams memory params = WithdrawalUtils.CreateWithdrawalParams(\n withdrawor, // receiver\n address(0), // call back function\n uiFeeReceiver, // uiFeeReceiver\n _marketProps1.marketToken, // which market token to withdraw\n longTokenSwapPath,\n shortTokenSwapPath,\n 123, // minLongTokenAmount\n 134, // minShortTokenAmount\n false, // shouldUnwrapNativeToken\n 3200, // execution fee\n 3200 // callback gas limit\n );\n\n vm.prank(withdrawor);\n bytes32 key = _erouter.createWithdrawal(params);\n return key;\n}\n\n\nfunction createDepositNoSwap(Market.Props memory marketProps, address depositor, uint amount, bool isLong) public returns (bytes32){\n address[] memory longTokenSwapPath;\n address[] memory shortTokenSwapPath;\n\n console.log("createDeposit with depositor: ");\n console.logAddress(depositor);\n\n vm.prank(depositor);\n _wnt.transfer(address(_depositVault), 3200); // execution fee\n if(isLong){\n console2.log("000000000000000000");\n vm.prank(depositor);\n IERC20(marketProps.longToken).transfer(address(_depositVault), amount); \n console2.log("bbbbbbbbbbbbbbbbbbbbbb");\n }\n else {\n console2.log("111111111111111111111111");\n console2.log("deposit balance: %d, %d", IERC20(marketProps.shortToken).balanceOf(depositor), amount);\n vm.prank(depositor);\n IERC20(marketProps.shortToken).transfer(address(_depositVault), amount);\n console2.log("qqqqqqqqqqqqqqqqqq");\n }\n \n\n DepositUtils.CreateDepositParams memory params = DepositUtils.CreateDepositParams(\n depositor,\n address(0),\n uiFeeReceiver,\n marketProps.marketToken,\n marketProps.longToken,\n marketProps.shortToken,\n longTokenSwapPath,\n shortTokenSwapPath,\n 100000, // minMarketTokens\n true,\n 3200, // execution fee\n 3200 // call back gas limit\n );\n\n console2.log("aaaaaaaaaaaaaaaaaaaaaaaaa");\n vm.prank(depositor);\n bytes32 key1 = _erouter.createDeposit(params);\n\n return key1;\n}\n\n/*\nfunction testCancelDeposit() public \n{\n address[] memory longTokenSwapPath;\n address[] memory shortTokenSwapPath;\n\n address(_wnt).call{value: 100e8}("");\n _wnt.transfer(address(_depositVault), 1e6);\n DepositUtils.CreateDepositParams memory params = DepositUtils.CreateDepositParams(\n msg.sender,\n address(0),\n address(111),\n _marketProps1.marketToken,\n _marketProps1.longToken,\n _marketProps1.shortToken,\n longTokenSwapPath,\n shortTokenSwapPath,\n 100000, // minMarketTokens\n true,\n 3200, // execution fee\n 3200 // call back gas limit\n );\n\n bytes32 key1 = _erouter.createDeposit(params);\n\n console.log("WNT balance of address(222) before cancelllation: %s", _wnt.balanceOf(address(222)));\n console.log("WNT balance of address(this) before cancelllation: %s", _wnt.balanceOf(address(this))); \n\n _roleStore.grantRole(address(222), Role.CONTROLLER); // to save a market's props\n vm.prank(address(222));\n _depositHandler.cancelDeposit(key1);\n console.log("WNT balance of address(222) after cancelllation: %s", _wnt.balanceOf(address(222)));\n console.log("WNT balance of address(this) after cancelllation: %s", _wnt.balanceOf(address(this))); \n}\n*/\n\nfunction testERC165() public{\n bool yes = _wnt.supportsInterface(type(IWNT).interfaceId);\n console2.log("wnt suppports deposit?");\n console2.logBool(yes);\n vm.expectRevert();\n yes = IERC165(address(_sol)).supportsInterface(type(IWNT).interfaceId);\n console2.logBool(yes);\n\n if(ERC165Checker.supportsERC165(address(_wnt))){\n console2.log("_wnt supports ERC165");\n }\n if(ERC165Checker.supportsERC165(address(_sol))){\n console2.log("_sol supports ERC165");\n }\n}\n\n function justError() external {\n // revert Unauthorized("abcdefg"); // 973d02cb\n // revert("abcdefg"); // 0x08c379a, Error selector\n // require(false, "abcdefg"); // 0x08ce79a, Error selector\n assert(3 == 4); // Panic: 0x4e487b71\n }\n\n function testErrorMessage() public{\n\n try this.justError(){} \n catch (bytes memory reasonBytes) {\n (string memory msg, bool ok ) = ErrorUtils.getRevertMessage(reasonBytes);\n console2.log("Error Message: "); console2.logString(msg);\n console2.log("error?"); console2.logBool(ok);\n } \n }\n\n \n function printAddresses() public{\n console2.log("_orderVault:"); console2.logAddress(address(_orderVault));\n console2.log("marketToken:"); console2.logAddress(address(_marketProps1.marketToken));\n } \n\n function printPoolsAmounts() public{\n console2.log("\n The summary of pool amounts: ");\n \n uint256 amount = MarketUtils.getPoolAmount(_dataStore, _marketProps1, _marketProps1.longToken);\n console2.log("Market: _marketProps1, token: long/nwt, amount: %d", amount);\n amount = MarketUtils.getPoolAmount(_dataStore, _marketProps1, _marketProps1.shortToken);\n console2.log("Market: _marketProps1, token: short/USDC, amount: %d", amount);\n \n amount = MarketUtils.getPoolAmount(_dataStore, _marketPropsAB, _marketPropsAB.longToken);\n console2.log("Market: _marketPropsAB, token: long/A, amount: %d", amount);\n amount = MarketUtils.getPoolAmount(_dataStore, _marketPropsAB, _marketPropsAB.shortToken);\n console2.log("Market: _marketPropsAB, token: short/B, amount: %d", amount);\n \n amount = MarketUtils.getPoolAmount(_dataStore, _marketPropsBC, _marketPropsBC.longToken);\n console2.log("Market: _marketPropsBC, token: long/B, amount:%d", amount);\n amount = MarketUtils.getPoolAmount(_dataStore, _marketPropsBC, _marketPropsBC.shortToken);\n console2.log("Market: _marketPropsBC, token: short/C, amount: %d", amount);\n \n amount = MarketUtils.getPoolAmount(_dataStore, _marketPropsCwnt, _marketPropsCwnt.longToken);\n console2.log("Market: _marketPropsCwnt, token: long/C, amount: %d", amount);\n amount = MarketUtils.getPoolAmount(_dataStore, _marketPropsCwnt, _marketPropsCwnt.shortToken);\n console2.log("Market: _marketPropsCwnt, token: short/wnt, amount: %d", amount);\n \n\n console2.log("\n");\n }\n \n}\n```\n | 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 memory account = \_getAccount(vc.subject);\n // fresh account, set start epoch and epochsPaid to beginning of current window\n if (account.principal == 0) {\n uint256 currentEpoch = block.number;\n account.startEpoch = currentEpoch;\n account.epochsPaid = currentEpoch;\n GetRoute.agentPolice(router).addPoolToList(vc.subject, id);\n }\n\n account.principal += vc.value;\n account.save(router, vc.subject, id);\n\n totalBorrowed += vc.value;\n\n emit Borrow(vc.subject, vc.value);\n\n // interact - here `msg.sender` must be the Agent bc of the `subjectIsAgentCaller` modifier\n asset.transfer(msg.sender, vc.value);\n}\n```\n | 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; // <= 9.22t\n uint48 interfaceFeeAmount; // <= 281m\n\n /* slot 1 */\n address interfaceFeeReceiver;\n bool interfaceFeeUnwrap;\n bytes11 __unallocated0__;\n}\n\nlibrary TriggerOrderLib {\n function store(TriggerOrderStorage storage self, TriggerOrder memory newValue) internal {\n if (newValue.side > type(uint8).max) revert TriggerOrderStorageInvalidError();\n if (newValue.comparison > type(int8).max) revert TriggerOrderStorageInvalidError();\n if (newValue.comparison < type(int8).min) revert TriggerOrderStorageInvalidError();\n if (newValue.fee.gt(UFixed6.wrap(type(uint64).max))) revert TriggerOrderStorageInvalidError();\n if (newValue.price.gt(Fixed6.wrap(type(int64).max))) revert TriggerOrderStorageInvalidError();\n if (newValue.price.lt(Fixed6.wrap(type(int64).min))) revert TriggerOrderStorageInvalidError();\n if (newValue.delta.gt(Fixed6.wrap(type(int64).max))) revert TriggerOrderStorageInvalidError();\n if (newValue.delta.lt(Fixed6.wrap(type(int64).min))) revert TriggerOrderStorageInvalidError();\n if (newValue.interfaceFee.amount.gt(UFixed6.wrap(type(uint48).max))) revert TriggerOrderStorageInvalidError();\n\n self.value = StoredTriggerOrder(\n uint8(newValue.side),\n int8(newValue.comparison),\n uint64(UFixed6.unwrap(newValue.fee)),\n int64(Fixed6.unwrap(newValue.price)),\n int64(Fixed6.unwrap(newValue.delta)),\n uint40(UFixed6.unwrap(newValue.interfaceFee.amount)),\n newValue.interfaceFee.receiver,\n newValue.interfaceFee.unwrap,\n bytes11(0)\n );\n }\n```\n | 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 revert message into memory.\n returndatacopy(0, 0, returnDataSize)\n\n // Revert with the same message.\n revert(0, returnDataSize)\n }\n\n switch returnDataSize\n case 32 {\n // Copy the return data into memory.\n returndatacopy(0, 0, returnDataSize)\n\n // Set success to whether it returned true.\n success := iszero(iszero(mload(0)))\n }\n case 0 {\n // There was no return data.\n success := 1\n }\n default {\n // It returned some malformed input.\n success := 0\n }\n }\n}\n```\n | 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 - precision));\n } else {\n return amount;\n }\n}\n```\n | 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}\n```\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 // The easiest way to bubble the revert reason is using memory via assembly\n\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n}\n```\n | none |
```\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 sendCrossDomainMessage(l2TokenBridge, _l2Gas, message);\n }\n```\n | 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) {\n revert ExceedsBalance();\n }\n {\n> (uint256 _srcPoolId, uint256 _dstPoolId) = abi.decode(_data, (uint256, uint256));\n _routerSwap(_dstChainId, _srcPoolId, _dstPoolId, _amount, _slippage, _oft, erc20);\n }\n }\n```\n | 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 let size := returndatasize()\n returndatacopy(ptr, 0, size)\n revert(ptr, size)\n }\n }\n emit ExecuteTransaction(owner, address(this), to, data, value);\n return returnData;\n }\n```\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 revert ERC4626ExceededMaxRedeem(owner, shares, maxShares);\n }\n uint256 possibleAssets = previewRedeem(shares); // @audit-info round down, which is correct because user won't get too many\n\n assets = _withdraw(possibleAssets, shares, receiver, owner);\n }\n```\n | 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 for (uint256 j; j < founderPct; ++j) {\n // Get the available token id\n baseTokenId = _getNextTokenId(baseTokenId);\n\n // Store the founder as the recipient\n tokenRecipient[baseTokenId] = newFounder;\n\n emit MintScheduled(baseTokenId, founderId, newFounder);\n\n // Update the base token id\n baseTokenId = (baseTokenId + schedule) % 100;\n }\n }\n..\n\n function _getNextTokenId(uint256 _tokenId) internal view returns (uint256) {\n unchecked {\n while (tokenRecipient[_tokenId].wallet != address(0)) {\n _tokenId = (++_tokenId) % 100;\n }\n\n return _tokenId;\n }\n }\n```\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 borrowing this number will increase (netfCash < 0),\n // when lending this number will decrease (netfCash > 0).\n totalUsedBorrowCapacity = int256(uint256(cap.totalUsedBorrowCapacity)).sub(netfCash);\n if (netfCash < 0) {\n // Always allow lending to reduce the total used borrow capacity to satisfy the case when the max borrow\n // capacity has been reduced by governance below the totalUsedBorrowCapacity. When borrowing, it cannot\n // go past the limit.\n require(totalUsedBorrowCapacity <= int256(uint256(cap.maxBorrowCapacity)), "Max Capacity");\n```\n | 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("cannot migrate withdrawal: %w", err)\n }\n\n abi, err := bindings.L1CrossDomainMessengerMetaData.GetAbi()\n if err != nil {\n return nil, err\n }\n\n // Migrated withdrawals are specified as version 0. Both the\n // L2ToL1MessagePasser and the CrossDomainMessenger use the same\n // versioning scheme. Both should be set to version 0\n versionedNonce := EncodeVersionedNonce(withdrawal.Nonce, new(big.Int))\n // Encode the call to `relayMessage` on the `CrossDomainMessenger`.\n // The minGasLimit can safely be 0 here.\n data, err := abi.Pack(\n "relayMessage",\n versionedNonce,\n withdrawal.Sender,\n withdrawal.Target,\n value,\n new(big.Int),\n withdrawal.Data,\n )\n if err != nil {\n return nil, fmt.Errorf("cannot abi encode relayMessage: %w", err)\n }\n\n // Set the outer gas limit. This cannot be zero\n gasLimit := uint64(len(data)*16 + 200_000)\n\n w := NewWithdrawal(\n versionedNonce,\n &predeploys.L2CrossDomainMessengerAddr,\n l1CrossDomainMessenger,\n value,\n new(big.Int).SetUint64(gasLimit),\n data,\n )\n return w, nil\n}\n```\n | 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(\n uint256 minPoolClaim, bytes calldata /* data */\n ) external override whenLocked onlyNotionalOwner {\n StrategyVaultState memory state = VaultStorage.getStrategyVaultState();\n\n (IERC20[] memory tokens, /* */) = TOKENS();\n uint256[] memory amounts = new uint256[](tokens.length);\n\n // All balances held by the vault are assumed to be used to re-enter\n // the pool. Since the vault has been locked no other users should have\n // been able to enter the pool.\n for (uint256 i; i < tokens.length; i++) {\n if (address(tokens[i]) == address(POOL_TOKEN())) continue;\n amounts[i] = TokenUtils.tokenBalance(address(tokens[i]));\n }\n\n // No trades are specified so this joins proportionally using the\n // amounts specified.\n uint256 poolTokens = _joinPoolAndStake(amounts, minPoolClaim);\n..SNIP..\n```\n | 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] = _rOwned[sender] - rAmount;\n _rOwned[recipient] = _rOwned[recipient] + rTransferAmount; \n _takeLiquidity(tLiquidity);\n _reflectFee(rFee, tFee);\n emit Transfer(sender, recipient, tTransferAmount);\n}\n```\n | none |
```\nfunction addLiquidity() external onlyOwner() {\n IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);\n uniswapV2Router = _uniswapV2Router;\n _approve(address(this), address(uniswapV2Router), _tTotal);\n uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());\n uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);\n swapEnabled = true;\n liquidityAdded = true;\n IERC20(uniswapV2Pair).approve(address(uniswapV2Router),type(uint256).max);\n}\n```\n | 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 defeated, node has responded\n deleteUint(keccak256(abi.encodePacked(daoNameSpace, "member.challenged.block", \_nodeAddress)));\n }else{\n // The challenge refute window has passed, the member can be ejected now\n if(getUint(keccak256(abi.encodePacked(daoNameSpace, "member.challenged.block", \_nodeAddress))).add(rocketDAONodeTrustedSettingsMembers.getChallengeWindow()) < block.number) {\n // Node has been challenged and failed to respond in the given window, remove them as a member and their bond is burned\n \_memberRemove(\_nodeAddress);\n // Challenge was successful\n challengeSuccess = true;\n }\n }\n // Log it\n emit ActionChallengeDecided(\_nodeAddress, msg.sender, challengeSuccess, block.timestamp);\n}\n```\n | 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) = _writeDataToRound({roundId: roundId, roundValue: 0});\n }\n\n _incrementUserDepositCount(roundId, round);\n\n // @review depositAmount can be "0"\n uint256 depositAmount = amounts[i];\n\n // @review 0 % ANY_NUMBER = 0\n if (depositAmount % roundValuePerEntry != 0) {\n revert InvalidValue();\n }\n uint256 entriesCount = _depositETH(round, roundId, roundValuePerEntry, depositAmount);\n expectedValue += depositAmount;\n\n entriesCounts[i] = entriesCount;\n }\n\n // @review will not fail as long as user deposits normally to 1 round\n // then he can deposit to any round with "0" amounts\n if (expectedValue != msg.value) {\n revert InvalidValue();\n }\n```\n | 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 if (success) {\n reserve -= withdrawal.amount;\n```\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, keccak256(abi.encode(claim.mintTo, claim.tokenId)))) {\n revert INVALID_MERKLE_PROOF(claim.mintTo, claim.merkleProof, settings.merkleRoot);\n }\n\n // Only allowing reserved tokens to be minted for this strategy\n IToken(tokenContract).mintFromReserveTo(claim.mintTo, claim.tokenId);\n }\n}\n```\n | 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.indexOf[lastKey] = index;\n delete map.indexOf[key];\n\n map.keys[index] = lastKey;\n map.keys.pop();\n}\n```\n | 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 currentParams.asset,\n currentParams.price,\n currentParams.signature\n );\n // Silently fail if the signature doesn't match\n if (!isSignerVerifed) {\n emit FailResolve(\n currentParams.queueId,\n "Router: Signature didn't match"\n );\n continue;\n }\n if (\n !queuedTrade.isQueued ||\n currentParams.timestamp != queuedTrade.queuedTime\n ) {\n // Trade has already been opened or cancelled or the timestamp is wrong.\n // So ignore this trade.\n continue;\n }\n\n // If the opening time is much greater than the queue time then cancel the trad\n if (block.timestamp - queuedTrade.queuedTime <= MAX_WAIT_TIME) {\n _openQueuedTrade(currentParams.queueId, currentParams.price);\n } else {\n _cancelQueuedTrade(currentParams.queueId);\n emit CancelTrade(\n queuedTrade.user,\n currentParams.queueId,\n "Wait time too high"\n );\n }\n\n // Track the next queueIndex to be processed for user\n userNextQueueIndexToProcess[queuedTrade.user] =\n queuedTrade.userQueueIndex +\n 1;\n }\n```\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 require(!s.claimed, "TokenSale: Already Claimed");\n\n uint256 left;\n (s.share, left) = _claim(s);\n require(left > 0, "TokenSale: Nothing to claim"); // @audit - problematic line \n uint256 refundTaxAmount;\n if (s.taxAmount > 0) {\n uint256 tax = userTaxRate(s.amount, msg.sender);\n uint256 taxFreeAllc = _maxTaxfreeAllocation(msg.sender) * PCT_BASE;\n if (taxFreeAllc >= s.share) {\n refundTaxAmount = s.taxAmount;\n } else {\n refundTaxAmount = (left * tax) / POINT_BASE; // tax refund is on the wrong amount \n }\n usdc.safeTransferFrom(marketingWallet, msg.sender, refundTaxAmount);\n }\n s.claimed = true;\n usdc.safeTransfer(msg.sender, left);\n emit Claim(msg.sender, left);\n }\n```\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.swapExactTokensForETHSupportingFeeOnTransferTokens(\n tokenAmount,\n 0, // accept any amount of ETH\n path,\n address(this),\n block.timestamp\n );\n\n}\n```\n | 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 = (outstandingisoUSD * minOpeningMargin) / LOAN_SCALE;\n require(colInUSD > borrowMargin , "Remaining debt fails to meet minimum margin!");\n }\n```\n | 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, amount0);\n if (amount1 > 0) token1.safeTransfer(msg.sender, amount1);\n } else {\n if (amount0 > 0) token0.safeTransferFrom(payer, msg.sender, amount0);\n if (amount1 > 0) token1.safeTransferFrom(payer, msg.sender, amount1);\n }\n}\n\nfunction uniswapV3SwapCallback(\n int256 amount0Delta,\n int256 amount1Delta,\n bytes calldata data\n) external override {\n require(msg.sender == address(pool));\n address payer = abi.decode(data, (address));\n\n if (amount0Delta > 0) {\n if (payer == address(this)) {\n token0.safeTransfer(msg.sender, uint256(amount0Delta));\n } else {\n token0.safeTransferFrom(payer, msg.sender, uint256(amount0Delta));\n }\n } else if (amount1Delta > 0) {\n if (payer == address(this)) {\n token1.safeTransfer(msg.sender, uint256(amount1Delta));\n } else {\n token1.safeTransferFrom(payer, msg.sender, uint256(amount1Delta));\n }\n }\n}\n```\n | 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 piece:\n mstore(\n freeMemoryPointer,\n 0x23b872dd00000000000000000000000000000000000000000000000000000000\n ) // Begin with the function selector.\n mstore(\n add(freeMemoryPointer, 4),\n and(from, 0xffffffffffffffffffffffffffffffffffffffff)\n ) // Mask and append the "from" argument.\n mstore(\n add(freeMemoryPointer, 36),\n and(to, 0xffffffffffffffffffffffffffffffffffffffff)\n ) // Mask and append the "to" argument.\n mstore(add(freeMemoryPointer, 68), amount) // Finally append the "amount" argument. No mask as it's a full 32 byte value.\n\n // Call the token and store if it succeeded or not.\n // We use 100 because the calldata length is 4 + 32 * 3.\n callStatus := call(gas(), token, 0, freeMemoryPointer, 100, 0, 0)\n }\n\n require(\n didLastOptionalReturnCallSucceed(callStatus),\n "TRANSFER_FROM_FAILED"\n );\n}\n```\n | 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_PUBLIC_SALE)\n ) {\n return SaleType.FirstPublicMint;\n } else if (\n (block.timestamp >=\n defaultSaleStartTime + DEFAULT_INITIAL_PUBLIC_SALE) &&\n (block.timestamp < defaultSaleStartTime + DEFAULT_PIXELMINT_SALE)\n ) {\n return SaleType.PixelMint;\n } else if (\n (block.timestamp >=\n defaultSaleStartTime + DEFAULT_PIXELMINT_SALE) &&\n (block.timestamp < defaultSaleStartTime + DEFAULT_PILLMINT_SALE)\n ) {\n return SaleType.PillMint;\n } else if (\n (block.timestamp >= defaultSaleStartTime + DEFAULT_PILLMINT_SALE) &&\n (block.timestamp < defaultSaleStartTime + DEFAULT_TEAMMINT_SALE)\n ) {\n return SaleType.TeamMint;\n } else if (\n (block.timestamp >= defaultSaleStartTime + DEFAULT_TEAMMINT_SALE)\n ) {\n return SaleType.LastPublicMint;\n }\n}\n```\n | none |