Implement Uniswap v4 swaps & avoid critical mistakes

1. The difference between zeroToOne and oneToZero swaps, and why the order matters
2. How exactInputForOutput and exactOutputForInput work, and when to use each
3. The nuts and bolts of implementing these swap types in your code
4. Decoding the SwapParams struct and mastering its use
5. Interpreting BalanceDelta results to understand your swap outcomes
6. Critical pitfalls to avoid and best practices for secure, efficient swaps

Ready to become a Uniswap swap maestro?

Introduction

1                 Token0                Token1
2                   |                     |
3                   |                     |
4                   v                     v
5  +----------------+---------------------+
6  |                |                     |
7  |    zeroToOne   |   exactInputForOutput
8  |                | ------------------>
9  |                |                     |
10  |    zeroToOne   |   exactOutputForInput
11  |                | ------------------>
12  |                |                     |
13  |    oneToZero   |   exactInputForOutput
14  |                | <------------------
15  |                |                     |
16  |    oneToZero   |   exactOutputForInput
17  |                | <------------------
18  |                |                     |
19  +----------------+---------------------+

The basics: zeroToOne and oneToZero

1function swap(
2    PoolKey memory key,
3    SwapParams memory params,
4    bytes calldata hookData
5) external returns (BalanceDelta);
6
7struct SwapParams {
8    bool zeroForOne;
9    int256 amountSpecified;
10    uint160 sqrtPriceLimitX96;
11}

Exactness in swaps: exactInputForOutput and exactOutputForInput

1int256 amountSpecified;

Swap function in-depth

Now that we've got the basics down, you might be thinking: "Okay, but how do I actually use these swap types in my code?"

1function swap(
2    PoolKey memory key,
3    SwapParams memory params,
4    bytes calldata hookData
5) external returns (BalanceDelta);

1. PoolKey memory key: This is like the address of our vending machine. It tells Uniswap which specific pool we want to interact with. Think of it as saying, "I want to swap between THIS token and THAT token."
2. SwapParams memory params: This is where the real magic happens. It's a struct that contains all the details about our swap. We'll dive deeper into this in a moment, but just know that this is where we specify things like which direction we're swapping and how much.
3. bytes calldata hookData: This is for any extra data that might be needed by hooks attached to the pool. Hooks are like little add-ons that can modify how the pool behaves. For most basic swaps, you can leave this empty, but it's good to know it's there.

And what do we get back?

1struct SwapParams {
2    bool zeroForOne;
3    int256 amountSpecified;
4    uint160 sqrtPriceLimitX96;
5}

1. zeroForOne: This little boolean is how we tell Uniswap which direction we're swapping. It's like flipping a switch to decide if we're going from Token0 to Token1 (true), or the other way around (false).
2. amountSpecified: This is where we specify how much we're swapping. But here's the twist - the sign of this number (positive or negative) determines whether we're doing an exactInputForOutput or an exactOutputForInput swap. Mind-bending, right?
3. sqrtPriceLimitX96: Don't let this scary-looking name fool you. It's just our safety net, making sure we don't get a raw deal if the market moves too much during our swap. (You don't know what this is? Take a look at our glossary on sqrtPriceX96)

Now, you might be wondering, "How do I actually use this to make the four types of swaps we talked about earlier?"

zeroToOne-exactInputForOutput

1SwapParams memory params = SwapParams({
2    zeroForOne: true,
3    amountSpecified: 1 ether,
4    // Don't do this in production!
5    sqrtPriceLimitX96: TickMath.MIN_SQRT_RATIO + 1
6});

zeroToOne-exactOutputForInput

1SwapParams memory params = SwapParams({
2    zeroForOne: true,
3    amountSpecified: -1 ether,
4    // Don't do this in production!
5    sqrtPriceLimitX96: TickMath.MIN_SQRT_RATIO + 1
6});

Now, after we press that metaphorical button and call swap, what do we get back?

1struct BalanceDelta {
2    int256 amount0;
3    int256 amount1;
4}

Potential pitfalls and developer considerations

Slippage surprises

1// Don't do this in production!
2sqrtPriceLimitX96: TickMath.MIN_SQRT_RATIO + 1

Decimal dilemmas

Size matters

Gas guzzlers

Error handling

Hook hazards

Testing, testing, 1–2–3

Conclusion

Get in touch

FAQ: Uniswap v4 swap mechanics

Glossary

Shipping a Uniswap V4 Hook or Integration?