Primex Contracts - Primex

The multiSwap function from the PrimexPricingLibrary.sol contract executes the token swap across the specified DEX and paths for opening and closing orders. However, when executing an order without leverage, the protocol sets the tolerable limit to zero, requiring for the swap to return an exact price given the oracle current prices.

This results in most of sport orders reverting, as the retrieved tokens are normally less than the strict oracle prices exchange.

Code Location

PrimexPricingLibrary.sol#L353-L359

PrimexPricingLibrary.sol

if (_needOracleTolerableLimitCheck) {
    _require(
        vars.balance >=
            getOracleAmountsOut(_params.tokenA, _params.tokenB, _params.amountTokenA, _priceOracle).wmul(
                WadRayMath.WAD - _maximumOracleTolerableLimit
            ),
        Errors.DIFFERENT_PRICE_DEX_AND_ORACLE.selector
    );

Consider allowing the _maximumOracleTolerableLimit for spot orders or avoid executing this code section as the minimum amount out is also checked and specified by the user.

SOLVED: The Primex team solved the issue by turning off oracle checks for manual closing of spot positions and kept oracle tolerable limit check obligatory for limit orders with non-zero tolerance.

Commit ID: 3532cdb3b5f7e59e031804f5d125ac957692cdf9

The functions decreaseTraderDebt and batchDecreaseTradersDebt of the Bucket.sol contract account the permanentLossScaled global state variable differently.

On the decreaseTraderDebt function, the liquidityIndex is first updated and the used the new value to compute the permanentLossScaled value. Whereas on the batchDecreaseTradersDebt function, the current liquidityIndex is used to compute the permanentLossScaled and then the index is updated.

Code Location

Bucket.sol#L365C1-L383C6

Bucket.sol

function decreaseTraderDebt(
    address _trader,
    uint256 _debtToBurn,
    address _receiverOfAmountToReturn,
    uint256 _amountToReturn,
    uint256 _permanentLossAmount
) external override onlyRole(PM_ROLE) {
    // don't need require on isLaunched,
    // because if we can't openPosition in this bucket then we can't closePosition in this bucket
    if (_amountToReturn != 0) {
        TokenTransfersLibrary.doTransferOut(address(borrowedAsset), _receiverOfAmountToReturn, _amountToReturn);
    }
    _updateIndexes();
    debtToken.burn(_trader, _debtToBurn, variableBorrowIndex);
    _updateRates();
    if (_permanentLossAmount != 0) {
        permanentLossScaled += _permanentLossAmount.rdiv(liquidityIndex);
    }
}

Bucket.sol#L388-L407

Bucket.sol

function batchDecreaseTradersDebt(
    address[] memory _traders,
    uint256[] memory _debtsToBurn,
    address _receiverOfAmountToReturn,
    uint256 _amountToReturn,
    uint256 _permanentLossAmount,
    uint256 _length
) external override onlyRole(BATCH_MANAGER_ROLE) {
    // don't need require on isLaunched,
    // because if we can't openPosition in this bucket then we can't closePosition in this bucket
    if (_amountToReturn != 0) {
        TokenTransfersLibrary.doTransferOut(address(borrowedAsset), _receiverOfAmountToReturn, _amountToReturn);
    }
    if (_permanentLossAmount != 0) {
        permanentLossScaled += _permanentLossAmount.rdiv(liquidityIndex);
    }
    _updateIndexes();
    debtToken.batchBurn(_traders, _debtsToBurn, variableBorrowIndex, _length);
    _updateRates();
}

Consider which is the appropriate way to handle the accounting of permanent loss and implement it consistently on both function.

SOLVED: The Primex team solved the issue by implementing suggestions consistently on both of the functions.

Commit IDs:

• 602ae25439fa7ae86d23069975624a531203d699

• 4aa13cf48667b77d46471a2f02d78727b1287204

The getExchangeRate function from the PriceOracle.sol contract calls the latestRoundData function from ChainLink price feeds. However, there is no check on the return values to validate stale data prices.

This could lead to stale prices according to the ChainLink documentation:

ChainLink Doc. Ref#1ChainLink Doc. Ref#2

Code Location

PriceOracle.sol#L73-L97

PriceOracle.sol

function getExchangeRate(address assetA, address assetB) external view override returns (uint256, bool) {
    address priceFeed = chainLinkPriceFeeds[assetA][assetB];
    bool isForward = true;

    if (priceFeed == address(0)) {
        priceFeed = chainLinkPriceFeeds[assetB][assetA];
        if (priceFeed == address(0)) {
            (address basePriceFeed, address quotePriceFeed) = getPriceFeedsPair(assetA, assetB);

            (, int256 basePrice, , , ) = AggregatorV3Interface(basePriceFeed).latestRoundData();
            (, int256 quotePrice, , , ) = AggregatorV3Interface(quotePriceFeed).latestRoundData();

            _require(basePrice > 0 && quotePrice > 0, Errors.ZERO_EXCHANGE_RATE.selector);
            //the return value will always be 18 decimals if the basePrice and quotePrice have the same decimals
            return (uint256(basePrice).wdiv(uint256(quotePrice)), true);
        }
        isForward = false;
    }

    (, int256 answer, , , ) = AggregatorV3Interface(priceFeed).latestRoundData();
    _require(answer > 0, Errors.ZERO_EXCHANGE_RATE.selector);

    uint256 answerDecimals = AggregatorV3Interface(priceFeed).decimals();
    return ((uint256(answer) * 10 ** (18 - answerDecimals)), isForward);
}

Consider adding the next code, validate the oracle response.

( roundId , rawPrice , , updateTime , answeredInRound ) =
AggregatorV3Interface(XXXXX).latestRoundData();
require(rawPrice > 0, "Chainlink price <= 0");
require(updateTime != 0, "Incomplete round");
require(answeredInRound >= roundId , "Stale price");

RISK ACCEPTED: The Primex team claims that accepting the risk of outdated oracle data is reasonable because it is logical not to block position liquidation or conditional closing based on such data. By the time the oracle reports the price, these positions should already be closed. Primex has an emergency pause system that allows EMERGENCY_ADMIN to pause borrowing funds from credit buckets and forbids opening new positions, etc. Each CL feed has a different heartbeat, and the normal heartbeat value is not stored on-chain, so the behavior of the oracle is monitored off-chain. If an insufficient price update frequency is detected, the corresponding components of the protocol will be paused until the oracle is stabilized. Additionally, the team will provide users in the Primex app with information regarding outdated oracle prices. In future versions, the team is considering implementing reserve oracles for critical situations like these.

The implementation contracts of the protocol that are used by proxies do not disable the initialize function.

An uninitialized contract can be taken over by an attacker, which map impact the proxy or be used for social engineering.

Consider adding the _disableInitializers function call on the constructor of each implementation.

SOLVED: The Primex team solved the issue by using the _disableInitializers in the constructor.

Commit ID: e9d04dedc78151cba0a759b90a3cbf6dd10add7c

Functions of Primex Protocol contracts use the TokenTransfersLibrary .sol to handle ERC20 transfers. Although this function returns the difference of balance of the caller before and after the call, this value is not used. As a result, the contract may account to a different value than what was actually transferred to the protocol.

Whenever tokens are transferred, the delta of the previous (before trans- fer) and current (after transfer) token balance should be verified to match the declared token amount.

RISK ACCEPTED: The Primex team accepted the risk of this issue and will not use such tokens in the current version. These ERC20 tokens are planned to be future compatible.

The openPosition function of the PositionManager.sol contract allows paying the fee of the execution either on native currency or PMX. However, the payProtocolFee function does not control if the transaction contains msg.value when the function is executed, paying in PMX. This effectively locks the native currency on the PositionManager contract.

Code Location

PositionManager.sol

PositionManager.sol

function openPosition(
    PositionLibrary.OpenPositionParams calldata _params
) external payable override nonReentrant whenNotPaused {
    _notBlackListed();
    (PositionLibrary.Position memory newPosition, PositionLibrary.OpenPositionVars memory vars) = PositionLibrary
        .createPosition(_params, primexDNS, priceOracle);
    PositionLibrary.OpenPositionEventData memory posEventData = _openPosition(newPosition, vars);

    PositionLibrary.Position memory position = positions[positions.length - 1];
    _updateTraderActivity(msg.sender, position.positionAsset, position.positionAmount, position.bucket);

PrimexPricingLibrary.sol#L444-L492

PrimexPricingLibrary.sol

function payProtocolFee(ProtocolFeeParams memory params) public returns (uint256 protocolFee) {
    ProtocolFeeVars memory vars;
    vars.treasury = params.primexDNS.treasury();
    vars.fromLocked = true;

    if (!params.isByOrder) {
        vars.fromLocked = false;
        params.depositData.protocolFee = getOracleAmountsOut(
            params.depositData.depositedAsset,
            params.feeToken,
            params.depositData.depositedAmount.wmul(params.depositData.leverage).wmul(
                params.feeToken == NATIVE_CURRENCY
                    ? params.primexDNS.protocolRate()
                    : params.primexDNS.protocolRateInPmx()
            ),
            params.priceOracle
        );
        if (params.isSwapFromWallet) {
            if (params.feeToken == NATIVE_CURRENCY) {
                _require(msg.value >= params.depositData.protocolFee, Errors.INSUFFICIENT_DEPOSIT.selector);
                TokenTransfersLibrary.doTransferOutETH(vars.treasury, params.depositData.protocolFee);
                if (msg.value > params.depositData.protocolFee) {
                    TokenTransfersLibrary.doTransferOutETH(
                        params.trader,
                        msg.value - params.depositData.protocolFee
                    );
                }
            } else {
                TokenTransfersLibrary.doTransferFromTo(
                    params.feeToken,
                    params.trader,
                    vars.treasury,
                    params.depositData.protocolFee
                );
            }
            return params.depositData.protocolFee;
        }
    }

    params.traderBalanceVault.withdrawFrom(
        params.trader,
        vars.treasury,
        params.feeToken,
        params.depositData.protocolFee,
        vars.fromLocked
    );

    return params.depositData.protocolFee;
}

Consider controlling the msg.value to give back the native currency or revert the transaction if appropriate.

SOLVED: The Primex team solved the issue by adding the check for native currency.

Commit IDs:

• e811a4a1f10a36780459cefb2d1d23090ff09a2f

• 3a038a73cca7ebc2455459378730016f4d78bab2

The Ptoken contract is used to account for the deposit and interest that lenders have on a specific bucket. The interest is not always accrued on time on the bucket, and a lender may attempt to burn its tokens without being enough funds on the bucket.

In this case, the protocol reverts with an error from the ERC20 token contract indicating transferred failed.

Code Location

Bucket.sol#L314-L350

Bucket.sol

function withdraw(address _borrowAssetReceiver, uint256 _amount) external override nonReentrant notBlackListed {
    if (!LMparams.isLaunched) {
        LMparams.liquidityMiningRewardDistributor.removePoints(name, msg.sender, _amount);
    } else if (block.timestamp < LMparams.stabilizationPeriodEnd) {
        _require(
            _amount <=
                pToken.balanceOf(msg.sender) -
                    LMparams.liquidityMiningRewardDistributor.getLenderAmountInMining(name, msg.sender),
            Errors.MINING_AMOUNT_WITHDRAW_IS_LOCKED_ON_STABILIZATION_PERIOD.selector
        );
    }

    _updateIndexes();
    uint256 amountToWithdraw = pToken.burn(msg.sender, _amount, liquidityIndex);
    uint256 amountToLender = (WadRayMath.WAD - withdrawalFeeRate).wmul(amountToWithdraw);
    uint256 amountToTreasury = amountToWithdraw - amountToLender;
    if (!LMparams.isLaunched && isInvestEnabled && aaveDeposit > 0) {
        // if liquidity mining failed, take all tokens from aave during first withdraw from bucket
        if (block.timestamp > LMparams.liquidityMiningDeadline) {
            _withdrawAllLiquidityFromAave();
        } else {
            // if liquidity mining is in progress, withdraw needed amount from aave
            address aavePool = dns.aavePool();
            IPool(aavePool).withdraw(address(borrowedAsset), amountToWithdraw, address(this));
            emit WithdrawFromAave(aavePool, amountToWithdraw);
            aaveDeposit -= amountToWithdraw;
        }
    }

    TokenTransfersLibrary.doTransferOut(address(borrowedAsset), dns.treasury(), amountToTreasury);
    emit TopUpTreasury(msg.sender, amountToTreasury);

    TokenTransfersLibrary.doTransferOut(address(borrowedAsset), _borrowAssetReceiver, amountToLender);
    _updateRates();

    emit Withdraw(msg.sender, _borrowAssetReceiver, amountToWithdraw);
}

PToken.sol#L169-L198

PToken.sol

function burn(address _user, uint256 _amount, uint256 _index) external override onlyBucket returns (uint256) {
    _require(_user != address(0), Errors.ADDRESS_NOT_SUPPORTED.selector);
    uint256 amountScaled;
    (_amount, amountScaled) = _getValidAmounts(_user, _amount, _index);
    if (address(interestIncreaser) != address(0)) {
        //in this case the _index will be equal to the getNormalizedIncome()
        try interestIncreaser.updateBonus(_user, scaledBalanceOf(_user), address(bucket), _index) {} catch {
            emit Errors.Log(Errors.INTEREST_INCREASER_CALL_FAILED.selector);
        }
    }

    if (address(lenderRewardDistributor) != address(0)) {
        try
            lenderRewardDistributor.updateUserActivity(
                bucket,
                _user,
                scaledBalanceOf(_user),
                (scaledTotalSupply() - amountScaled),
                IActivityRewardDistributor.Role.LENDER
            )
        {} catch {
            emit Errors.Log(Errors.LENDER_REWARD_DISTRIBUTOR_CALL_FAILED.selector);
        }
    }

    _burn(_user, amountScaled);

    emit Burn(_user, _amount);
    return _amount;
}

Consider controlling this scenario and revert with the corresponding error.

SOLVED: The Primex team solved the issue by adding a require statement.

Commit ID: 868eb9da1b22c03415b2d244a3bd836d76abf40a

The function _updateIndexes function is a critical operation that updates the liquidityIndex and variableBorrowIndex storage variables. These variables are used to account the amounts that lenders and borrowers should receive/return. But this critical operation does not emit an event to help to monitor the protocol.

Code Location

Bucket.sol#L576-L590

Bucket .sol

function _updateIndexes() internal {
    uint256 cumulatedLiquidityInterest = _calculateLinearInterest(lar, lastUpdatedBlockTimestamp);
    uint256 newLiquidityIndex = cumulatedLiquidityInterest.rmul(liquidityIndex);
    _require(newLiquidityIndex <= type(uint128).max, Errors.LIQUIDITY_INDEX_OVERFLOW.selector);
    liquidityIndex = uint128(newLiquidityIndex);

    uint256 cumulatedVariableBorrowInterest = _calculateCompoundedInterest(bar, lastUpdatedBlockTimestamp);
    uint256 newVariableBorrowIndex = cumulatedVariableBorrowInterest.rmul(variableBorrowIndex);
    _require(newVariableBorrowIndex <= type(uint128).max, Errors.BORROW_INDEX_OVERFLOW.selector);
    uint256 previousVariableBorrowIndex = variableBorrowIndex;
    variableBorrowIndex = uint128(newVariableBorrowIndex);

    lastUpdatedBlockTimestamp = block.timestamp;
    _mintToReserve(debtToken.scaledTotalSupply(), previousVariableBorrowIndex, variableBorrowIndex);
}

Consider omitting an event to help protocol monitoring.

SOLVED: The Primex team solved the issue by adding another parameter to the event.

Commit ID: 53578af0ae4c20291f414baab11df0525f25c635

The introduction of EIP-3855 introduces a breaking change that prevents solidity compiled code to execute on L2 chains. As the protocol expects to work on different chains and contains the floating pragma ^0.8.18, it is advised not to use this solidity version.

Avoid using floating pragma that can result to compile with this solc version.

SOLVED: The Primex team solved the issue by changing the floating pragma with 0.8.18.

Commit ID: 2a2dcc15ec03833d5a7bc42c8c1c29a8f251d583

While the DIV opcode uses 5 gas, the SHR opcode only uses 3 gas. Furthermore, Solidity’s division operation also includes a division-by-0 prevention, which is bypassed using shifting.

Code Location

FeeExecutor.sol#L311

FeeExecutor.sol

while (lowest < highest) {
    if (lowest == highest - 1) break;
    uint256 mid = (lowest + highest) / 2;
    uint256 midTimestamp = updatedTimestamps[mid];
    if (_bonusDeadline < midTimestamp) {
        highest = mid;
    } else if (_bonusDeadline > midTimestamp) {
        lowest = mid;
    } else {
        return indexes[midTimestamp];
    }
}

Bucket.sol#L714-L715

Bucket.sol

function _calculateCompoundedInterest(uint256 _bar, uint256 _blockTimestamp) internal view returns (uint256) {
    uint256 exp = block.timestamp - _blockTimestamp;

    if (exp == 0) {
        return WadRayMath.RAY;
    }

    uint256 expMinusOne = exp - 1;
    uint256 expMinusTwo = exp > 2 ? exp - 2 : 0;
    // multiply first to mitigate rounding related issues
    uint256 basePowerTwo = _bar.rmul(_bar) / (SECONDS_PER_YEAR * SECONDS_PER_YEAR);
    uint256 basePowerThree = _bar.rmul(_bar).rmul(_bar) / (SECONDS_PER_YEAR * SECONDS_PER_YEAR * SECONDS_PER_YEAR);

    uint256 secondTerm = (exp * expMinusOne * basePowerTwo) / 2;
    uint256 thirdTerm = (exp * expMinusOne * expMinusTwo * basePowerThree) / 6;

    return WadRayMath.RAY + (_bar * exp) / SECONDS_PER_YEAR + secondTerm + thirdTerm;
}

PriceOracle.sol#L36-L39

PriceOracle.sol

function increasePairVolatility(
    address _assetA,
    address _assetB,
    uint256 _pairVolatility
) external override onlyRole(EMERGENCY_ADMIN) {
    _require(
        _pairVolatility > pairVolatilities[_assetA][_assetB] && _pairVolatility <= WadRayMath.WAD / 2,
        Errors.PAIRVOLATILITY_IS_NOT_CORRECT.selector
    );
    _setPairVolatility(_assetA, _assetB, _pairVolatility);
}

WadRayMath.sol#L17-L34

WadRayMath.sol

    function wmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = add(mul(x, y), WAD / 2) / WAD;
    }

    //rounds to zero if x*y < WAD / 2
    function rmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = add(mul(x, y), RAY / 2) / RAY;
    }

    //rounds to zero if x*y < WAD / 2
    function wdiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = add(mul(x, WAD), y / 2) / y;
    }

    //rounds to zero if x*y < RAY / 2
    function rdiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = add(mul(x, RAY), y / 2) / y;
    }

Consider using a shift operator instead of diving by a constant to save gas.

ACKNOWLEDGED: The Primex team acknowledged this finding.

Initializing variables to the default value executes an extra order that is not required.

Code Location

FeeExecutor.sol#L294

FeeExecutor.sol

 uint256 lowest = 0;

UniswapInterfaceMulticall.sol#L30

UniswapInterfaceMulticall.sol

for (uint256 i = 0; i < calls.length; i++) {

LimitOrderLibrary.sol#L469

LimitOrderLibrary.sol

for (uint256 i = 0; i < A.length - 1; i++) {

Consider avoiding initializing variables to default value.

SOLVED: The Primex team solved the issue by avoiding initializing variables to default value.

Commit ID: 694e59382fb9e378fecef1ef23af23b097c7bc10

If not cached, the solidity compiler will always read the length of the array during each iteration. That is, if it is a storage array, this is an extra sload operation (100 additional extra gas for each iteration except for the first) and if it is a memory array, this is an extra mload operation (3 additional gas for each iteration except for the first).

The identified loops withing the protocol that can be optimized are:

• ActivityRewardDistributor.sol L89, L250

• BatchManager.sol L90, L133, L158, L173, L189, L229, L242, L291

• FeeExecutor.sol L51, L87

• Bucket.sol L76

• DexAdapter.sol L221, L300, L359, L442

• EPMXToken.sol L42, L54

• LimitOrderManager.sol L86, L103, L180, L200, L257, L282

• ReferralProgram.sol L83, L94, L95

• BalancerBotLens.sol L15, L31, L61

• TraderBalanceVault.sol L133

• UniswapInterfaceMulticall.sol L30

• WhiteBlackListBase L33, L45, L51, L65

• BestDexLens.sol L283

• PrimexLens.sol L136, L249, L282, L316, L494

• LimitOrderLibrary L274, L302, L469, L470

• PositionLibrary.sol L480

• PrimexPricingLibrary.sol L172, L139, L145, L176, L188, L193, L268, L272, L324, L333, L341

Consider caching the array length before iterating over it.

ACKNOWLEDGED: The Primex team acknowledged the issue.

Using ++i instead of i++ saves 5 gas per loop iteration.

The identified loops withing the protocol that can be optimized are:

• ActivityRewardDistributor.sol L79, L89, L250

• BatchManager.sol L90, L158, L189, L229, L242, L291

• FeeExecutor.sol L51, L87, L131

• Bucket.sol L76, L464

• DebtToken L142, L154

• DexAdapter.sol L221, L300, L359, L442, L462, L478

• EPMXToken.sol L42, L54

• LimitOrderManager.sol L90, L221, L225

• PrimexUpkeep.sol L86, L103, L129, L147, L180, L200, L232, L257, L282, L310

• ReferralProgram.sol L83, L94, L95

• SpotTradingRewardDistributor.sol L160

• BalancerBotLens.sol L15, L31, L61

• TraderBalanceVault.sol L133

• UniswapInterfaceMulticall.sol L30

• WhiteBlackListBase L33, L45, L51, L65

• BestDexLens.sol L283

• PrimexLens.sol L136, L249, L282, L316, L494

• LimitOrderLibrary L274, L302, L469, L470

• PositionLibrary.sol L480

• PrimexPricingLibrary.sol L172, L139, L145, L176, L188, L193, L268, L272, L324, L333, L341

Consider replacing i++ to ++i in all indicated for loops.

ACKNOWLEDGED: The Primex team acknowledged the issue.

Custom errors from Solidity 0.8.4 are cheaper than revert strings (cheaper deployment cost and runtime cost when the revert condition is met). Source Custom Errors in Solidity: Starting from Solidity v0.8.4, there is a convenient and gas-efficient way to explain to users why an operation failed through the use of custom errors. Until now, you could already use strings to provide additional information about failures (e.g., revert(“Insufficient funds.“);), but they are rather expensive, especially when it comes to deploy cost, and it is difficult to use dynamic information in them.

Code Location

PrimexPricingLibrary.sol#L553

PrimexPricingLibrary.sol

revert("DexAdapter::decodePath: UNKNOWN_DEX_TYPE");

WadRayMath.sol#L6-L10

WadRayMath.sol

function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
    require((z = x + y) >= x, "ds-math-add-overflow");
}

function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
    require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
}

Consider replacing strings for custom errors, as done in the rest of the protocol implementation.

SOLVED: The Primex team solved the issue by using custom errors.

Commit ID: b10edc72fe57411bfeff984f92805d560f3e28eb

Use uint256(1) and uint256(2) for true/false to avoid a Gwarmaccess (100 gas), and to avoid Gsset (20000 gas) when changing from ‘false’ to ‘true’, after having been ‘true’ in the past. See source.

Code Location

Instances (3):

File: Bucket/BucketStorage.sol

57:     bool public isInvestEnabled;

File: EPMXToken.sol

14:     mapping(address => bool) public whitelist;

File: PMXBonusNFT/PMXBonusNFTStorage.sol

27:     mapping(uint256 => bool) internal isBlocked;

Consider avoiding the usage of boolean types for storage variables.

ACKNOWLEDGED: The Primex team acknowledged the issue.

Primex protocol contract uses the floating pragma ^0.8.18. Contracts should be deployed with the same compiler version and flags that they have been tested with thoroughly. Locking the pragma helps to ensure that contracts do not accidentally get deployed using another pragma, for example, either an outdated pragma version that might introduce bugs that affect the contract system negatively or a recently released pragma version which has not been extensively tested.

This issue, specifically, aligns with the previous described misbehave on different chains if solidity version 0.8.20 is used.

Consider locking the pragma version, known bugs for the compiler version. Therefore, it is recommended not to use floating pragma in production.

SOLVED: The Primex team solved the issue by locking pragma to 0.8.18.

Commit ID: 2a2dcc15ec03833d5a7bc42c8c1c29a8f251d583