# Slippage tolerance vulnerability

{% hint style="info" %}
[**Book an audit with Zokyo**](https://www.zokyo.io/)
{% endhint %}

#### **Introduction**

As DeFi protocols continue to amass users and value, ensuring security and functionality becomes increasingly important. Among the myriad of potential vulnerabilities in this space, the "0 Slippage Tolerance Vulnerability" has emerged as a significant concern. By delving into its mechanics, impact, and potential mitigation strategies, we can better understand the intricacies of DeFi and work towards more robust systems.

#### **What is 0 Slippage Tolerance?**

In DeFi, "slippage" refers to the difference between the expected price of a trade and the price at which the trade is executed. When a protocol enforces a "0 Slippage Tolerance", it essentially dictates that trades can only be executed if they match the expected price perfectly, without even the slightest deviation. On the surface, this might seem beneficial, as it could protect users from receiving a worse rate than anticipated. However, in practice, this strict constraint can introduce multiple vulnerabilities.

#### **The Vulnerability Explained**

**Impact:**

The heart of this vulnerability lies in the inability of a system to accommodate any price variation when executing trades. For instance, let's consider a`LaunchEvent.sol createPair()` function. This function calls the `router.addLiquidity()` with an expectation that the desired amounts of both assets A and B are identical to their minimum required amounts. Without any leeway for slippage, if this precise requirement isn't met, the function reverts.

In real-world scenarios, this could manifest in multiple ways:

1. **Front-running Attacks:** Malicious actors can intentionally manipulate the price, forcing the zero slippage requirement to fail. They can do this by observing transactions in the mempool and acting strategically before those transactions are confirmed.
2. **Liquidity Pool Restrictions:** If a liquidity pool, for any reason, cannot accommodate a zero slippage trade with its held assets, users are prevented from executing their desired trades, diminishing the protocol's usability.

**Proof of Concept:**

Using the aforementioned `LaunchEvent.sol` as an example, the code might have been designed under the assumption that only a particular entity would have a balance of the new token pre-launch. This assumption can be flawed if the token distribution is not controlled by the protocol, allowing others to have the token before the official release.

A malicious actor with early access to the new token could exploit the zero slippage requirement by manipulating token ratios, ensuring the strict conditions are not met, and causing the function to revert.

#### **Mitigation Steps**

Recognizing that DeFi systems operate in dynamic environments, introducing some flexibility is essential. To address the 0 Slippage Tolerance Vulnerability:

1. **Introduce Slippage Allowance:** Rather than hardcoding a zero-tolerance, allow users or the protocol to define a permissible slippage range. This provides a buffer, enhancing the chances of trade execution while still protecting users from extreme price deviations.
2. **Educate Users:** Inform users about the implications of slippage and its potential impacts on their trades. An informed user can make better decisions regarding acceptable slippage based on market conditions.

#### **Conclusion**

DeFi's dynamism demands that protocols be both secure and adaptable. The 0 Slippage Tolerance Vulnerability underscores the need for a balanced approach, considering both user protection and system functionality. By understanding these nuances and adapting accordingly, the DeFi space can continue its path toward revolutionizing the financial ecosystem.

Example:&#x20;

{% embed url="<https://github.com/code-423n4/2022-01-trader-joe-findings/issues/146>" %}
