uniswap – Fixing Price Impact Issues on Uniswap DAI/USDT Pair

uniswap

Following the documentation here: https://uniswap.org/docs/v2/javascript-SDK/pricing/

I have been able to replicate the results using WETH, and I have decided to have a go at getting a similar result with DAI and USDT.

const { ChainId, Fetcher, Route, Trade, TokenAmount, TradeType, WETH } = require('@uniswap/sdk');

const init = async () => {
    const dai = await Fetcher.fetchTokenData(ChainId.MAINNET, '0x6B175474E89094C44Da98b954EedeAC495271d0F');
    const tether = await Fetcher.fetchTokenData(ChainId.MAINNET, '0xdAC17F958D2ee523a2206206994597C13D831ec7');
    
    const pair = await Fetcher.fetchPairData(dai, tether);
    const route = new Route([pair], tether);

    const trade = new Trade(route, new TokenAmount(tether, '1000000000000000000'), TradeType.EXACT_INPUT);
};

init();

I retrieve the Token Data for both Dai and Tether, then fetch pair data which I then put into a route.

These abovementioned steps must be correct as the an in-function log of

console.log(route.midPrice.toSignificant(6));
console.log(route.midPrice.invert().toSignificant(6));

return values that make sense.

Where things become odd is with

console.log(trade.priceImpact.toSignificant(6));
console.log(trade.executionPrice.toSignificant(6));
console.log(trade.outputAmount.toSignificant(6));

According to these results, my price impact is at 100, the execution price is around 0.000000278029, and the output amount is at 278028.

This doesn't sound right at all.

What is the mistake in my code that brings about this error?

Best Answer

There is a decimal mistake in the TokenAmount. It is important to check how many decimals any specific token has. While 1000000000000000000 wei is 1 ether, 1000000000000000000 specified for USDT, which has 6 decimal places, would equal 1000000000000, which is much greater than the current liquidity supply on Uniswap. 1000000 specified for USDT would equal 1 USDT and return reasonable results for

console.log(trade.priceImpact.toSignificant(6));
console.log(trade.executionPrice.toSignificant(6));
console.log(trade.outputAmount.toSignificant(6));

Short answer

Given a liquidity pool with token A and token B, let:

reserve_a_initial be the amount of token A in the liquidity pool before the trade
reserve_b_initial be the amount of token B in the liquidity pool before the trade (not required to calculate the price impact)
fee be the trading fee. For PancakeSwap, this is 0.0025
amount_traded be the amount of token A traded

To calculate the price impact:

amountInWithFee = amount_traded * (1 - fee);
price_impact = amountInWithFee / (reserve_a_initial + amountInWithFee);

Explanation

This article explains how to calculate the price impact. However, please note that what the article refers to as the "current market price" or "market rate", I refer to as the mid_price. Now, let's calculate the price_impact:

constant_product = reserve_a_initial * reserve_b_initial;
reserve_b_after_execution = constant_product / (reserve_a_initial + amountInWithFee);
amountOut = reserve_b_initial - reserve_b_after_execution;
market_price = amountInWithFee / amountOut;
mid_price = reserve_a_initial / reserve_b_initial;
price_impact = 1 - (mid_price / market_price);

Before substituting and simplifying, let:

reserve_a_initial be $r_{a0}$
reserve_b_initial be $r_{b0}$
reserve_b_after_execution be $r_{b1}$
amount_traded be $a_{traded}$
fee be $f$
amountInWithFee be $a_{in}$
constant_product be $k$
amountOut be $a_{out}$
market_price be $p_{market}$
mid_price be $p_{mid}$
price_impact be $price_{impact}$

Now for the math:

$a_{in} = a_{traded}(1-f)$

$k = r_{a0} \cdot r_{b0}$

$r_{b1} = \frac{k}{r_{a0} + a_{in}} = \frac{r_{a0} \cdot r_{b0}}{r_{a0} + a_{in}}$

$a_{out} = r_{b0} - r_{b1} = r_{b0} - \frac{r_{a0} \cdot r_{b0}}{r_{a0} + a_{in}} = \frac{r_{b0}(r_{a0} + a_{in}) - r_{a0} \cdot r_{b0}}{r_{a0} + a_{in}} = \frac{r_{b0} \cdot a_{in}}{r_{a0} + a_{in}}$

$p_{market} = \frac{a_{in}}{a_{out}} = a_{in} \div \frac{r_{b0} \cdot a_{in}}{r_{a0} + a_{in}} = \frac{r_{a0} + a_{in}}{r_{b0}}$

$p_{mid} = \frac{r_{a0}}{r_{b0}$

$price_{impact} = 1 - \frac{p_{mid}}{p_{market}} = 1 - \frac{r_{a0}}{r_{b0}} \div \frac{r_{a0} + a_{in}}{r_{b0}} = 1 - \frac{r_{a0}}{r_{a0} + a_{in}} = \frac{a_{in}}{r_{a0} + a_{in}}$

I found this mind-blowing, but the amount of token B in the pool doesn't affect the price_impact. However, reserve_b_initial will affect amount_out.

Calculating `amount_traded` given the `price_impact`

Rearranging the price_impact equation, it is possible to calculate amount_traded for a given price_impact:

$a_{traded} = \frac{r_{a0} \cdot price_{impact}}{(1 - price_{impact})(1-f)}$

Slippage and minimum amount received

To account for slippage, s, and calculate the minimum received, amount_out_min:

amount_out_min = amount_out * (1 - s);

Slippage does not affect price_impact.

Sample code

I don't know if there's a function in a PancakeSwap contract that will directly return the price_impact, but you can get the reserves of a pool and then calculate it. Let's take CAKE-USDT as an example:

import { Contract, utils, providers } from 'ethers';
const poolAddress = '0xa39af17ce4a8eb807e076805da1e2b8ea7d0755b'; // CAKE-USDT
const poolContract = new Contract(
    poolAddress,
    ['function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast)'],
    new providers.WebSocketProvider(PROVIDER_URL)
);

poolContract.getReserves()
    .then((reserves) => {
        let reserve_a_initial = parseFloat(utils.formatUnits(reserves._reserve0));
        let reserve_b_initial = parseFloat(utils.formatUnits(reserves._reserve1));
        console.log(`CAKE in pool: ${reserve_a_initial}`);
        console.log(`USDT in pool: ${reserve_b_initial}`);

        const fee = 0.0025;
        let max_price_impact = 0.01;
        let amount_traded_cake = reserve_a_initial * max_price_impact / ((1 - max_price_impact)*(1 - fee));
        let amount_traded_usdt = reserve_b_initial * max_price_impact / ((1 - max_price_impact)*(1 - fee));
        console.log(`Given a max price impact of ${max_price_impact*100}%, the max amount of CAKE tradeable is ${amount_traded_cake}`);
        console.log(`Given a max price impact of ${max_price_impact*100}%, the max amount of USDT tradeable is ${amount_traded_usdt}`);

        let amountInCAKE = amount_traded_cake * (1 - fee);
        let amountInUSDT = amount_traded_usdt * (1 - fee);
        let price_impact_trade_cake = amountInCAKE / (reserve_a_initial + amountInCAKE);
        let price_impact_trade_usdt = amountInUSDT / (reserve_b_initial + amountInUSDT);
        console.log(`Price impact when trading ${amount_traded_cake} CAKE: ${price_impact_trade_cake*100}%`);
        console.log(`Price impact when trading ${amount_traded_usdt} USDT: ${price_impact_trade_usdt*100}%`);
    }).catch(console.error);

Sample results:

CAKE in pool: 1030240.4016832297
USDT in pool: 19974605.474162016
Given a max price impact of 1%, the max amount of CAKE tradeable is 10432.550079068678
Given a max price impact of 1%, the max amount of USDT tradeable is 202269.36507087937
Price impact when trading 10432.550079068678 CAKE: 1%
Price impact when trading 202269.36507087937 USDT: 1%

Please note that the price shown on the PancakeSwap UI is the execution_price:

execution_price = amount_traded / amountOut;

uniswap – Resolving Price Inconsistencies Between Uniswap and SushiSwap

I think what's going is that you are confused about the number of decimals. One ETH is 10^18 wei. But the USDC and USDT tokens only have 6 decimals: one USDC or USDT is only 10^6 of the basic unit.

Your code is converting the USDT amount to "wei" by multiplying one with 10^18, instead of 10^6 as should be correct. The results are incorrect by a factor of 10^12. In other words you're trying to swap 10^12 USDT for USDC. This is a huge number, so you get a huge price impact and the results is completely not what you expect.

If you change your function like this, the resulting USDT to USDC exchange rate should be close to 1.0:

DECIMALS = 6

def calcSell(contract,from_token,to_token):
        oneToken = 10**DECIMALS
        price = contract.functions.getAmountsOut(oneToken, [from_token, to_token]).call()
        normalizedPrice = price[1] / 10**DECIMALS
        normalizedPrice  = f'{normalizedPrice:.30f}'
        return normalizedPrice

Best Answer

Related Solutions

[Ethereum] Understand price impact and liquidity in pancakeswap