Implementing a flash swap with Uniswap V3

In this article, we’re going to write a smart contract that implements a flash swap by integrating Uniswap V3 contracts. This guide is just for learning purposes and the code below is not fully ready for production.

The idea of a flash swap is to have tokens before having to pay for them. Imagine there is a pool tokenA/tokenB. Then you have spotted that you can get more tokens by exchanging tokenB with tokenA in another fee tier. What you can do is get tokenB from the first pool before paying equivalent tokenA and go execute the swap in another fee tier where you can get more tokenA. Then later on come back and compensate the amount of tokenB that you took from the original pool with tokenA and keep the rest of the tokens as a profit. More concrete, let’s say you have a pool of USDC/USDT that can be swapped at 0.99–1(I mean 0.99USDC = 1USDT) in a certain fee tier. But then you realize that there is another fee tier where you could get 1USDT = 1.01USDC. In this case, you could get USDT from the first pool then go and do the swap in the second pool, then come back to the first pool with the USDC that you swapped and pay the equivalent amount of USDC in pool one. To keep the pool stable, Uniswap uses the formula x.y=k.

Pool 1: 0.99USDC = 1 USDT

Pool 2: 1 USDT = 1.01 USDC

This means that if you execute a flash swap of 10000000USDT in pool1

Then you go and execute the swap in pool2, 10000000USDT = 10100000 USDC

Lastly, you come back to pool1 and pay for the USDT that you took earlier.

After paying all the protocol fees, you can keep the remaining tokens.

This is just an example to show you exactly how a flash swap can work in theory.

Let’s now implement the smart contract

First, in your command line(terminal) create a directory and name it however you want, then navigate into that directory.

Depending on whether you’re using npm or yarn you can run `npm i hardhat` or `yarn add hardhat`. This will install all the dependencies that you’ll need. When that’s done installing, run `npx hardhat` to create a new project layout.

Before we do any coding, we’ll need to install Uniswap dependencies that contain all the required contracts for our project. Let’s do that by running `npm i @uniswap/v3-core @uniswap/v3-periphery`.

Now that we have those dependencies installed, let’s create a contract called FlashSwap under `contracts` folder. Now that the contract is created, we’re going to import a number of contracts from Uniswap dependencies that we have just installed.

This is how your contract should look like with all the imported contracts.

Next step, we will make our contract inherit from IUniswapV3FlashCallback and PeripheryPayments. These contracts also inherit from other contracts such as LowGasSafeMath under the hood. This means that our contract will have access to functions from those ancestor contracts as well.

Now, we’re going to implement LowGasSafeMath for all our uint256 and int256. We’re also going to declare an immutable and public variable called swapRouter which will be of type ISwapRouter(from Uniswap interfaces).

Let’s declare the constructor and pass in all the values that we need to specify right at the deployment time.

constructor(ISwapRouter _swapRouter,address _factory,address _WETH) PeripheryImmutableState(_factory, _WETH9) {
   swapRouter = _swapRouter;
}

In the constructor, we’re passing a number of parameters such as _swapRouter which is the address of the v3 swap router, we’re passing the address of the factory from which we’re going to execute the flash swap, and finally passing in the address of WETH9 which is the ERC20 wrapper for Ether.

Before calling the flash function, we’ll need to define all the parameters necessary for our flash swap as well as the data to pass to the callback function. We’ll define both of them in structs.

Let’s call the first struct FlashParams which will contain the needed parameters for the initial call

struct FlashParams {
    address token0;
    address token1;
    uint24 fee1;
    uint256 amount0;
    uint256 amount1;
    uint24 fee2;
    uint24 fee3;
}

The second struct will be called FlashCallbackData which will contain the necessary data to be passed on the callback

struct FlashCallbackData {
   uint256 amount0;
   uint256 amount1;
   address payer;
   PoolAddress.PoolKey poolKey;
   uint24 poolFee2;
   uint24 poolFee3;
}

Let’s now work on our swap function.

We’re going to name our function `initFlash`and pass in a parameter named params of type FlashParams. Our function is an `external` function.

Inside of our function body, let’s start by assigning the necessary parameters to our variable `poolKey`.

Next, we will declare another variable called `pool` of type IUniswapV3Pool which will allow us to call `flash` on our desired pool.

Now that we have our pool initialized, we can call `flash` on that pool. In the last parameter of our pool() function, we shall encode FlashCallbackData -the struct that we defined earlier- which will be decoded in the callback and inform about the next steps of the transaction.

Here’s how our `initFlash` function looks like

Let’s work on our callback function.

We shall name this function `uniswapV3FlashCallback` and `override` it to create our own logic. Our function will take 3 parameters which are: uint256 fee0, uint256 fee1, and bytes data which is the data that we encoded with abi.encode() in the previous function.

In the function body, let’s decode `data` and store it in a variable called decodedData which is of type FlashCallbacData(struct).

FlashCallbackData memory decodedData = abi.decode(data, (FlashCallbackData));

Before going any further, we need to validate that the call came from a valid V3Pool. We do that as follows

CallbackValidation.verifyCallback(factory, decoded.poolKey);

After that, we’ll create 2 variables token0 and token1 of type `address`, assigning them different values to approve the router to interact with the tokens from the flash.

address token0 = decoded.poolKey.token0;
address token1 = decoded.poolKey.token1;
TransferHelper.safeApprove(token0, address(swapRouter), decoded.amount0);
TransferHelper.safeApprove(token1, address(swapRouter), decoded.amount1);

Let’s add minimum amounts as well so that the trade can fail/revert if we do not get any profit

uint256 amount1Min = LowGasSafeMath.add(decoded.amount1, fee1);
uint256 amount0Min = LowGasSafeMath.add(decoded.amount0, fee0);

Now, we can execute the swap. This process will happen in 2 steps.

In the first step, we are going to call `exactInputSingle` on the router interface contract. We are going to use our variable `amount0Min` as our minimum variable out and store the value from the swap into a variable called `amountOutput0`.

We’ll proceed with the second swap as well with the last fee tier and the initial amount `amount0` that we got from the initial(original) pool. This process is the same as the first one but with different parameters.

Now that both swaps are made, we need to pay back the original pool.

We do that by calculating the amount of money that we owe the pool as well as the swapping fees then we approve the `swapRouter` to transfer those tokens from our contract back to the original pool.

The whole implementation of the function is as follows

That’s it for the whole implementation of the flash swap.

With this, you have gotten an idea of how you can implement a flash swap using Uniswap V3 contracts in your own contract. You can customize this contract as you want. You can maybe change the minimum value to only allow a profit value that’s between a certain range. Just an idea from me

You can find the full contract here

Until next time, keep #BUIDLING