Liquidity pools and how token prices change in decentralized exchanges like Uniswap

In a decentralized exchange (DEX) like Uniswap, users can swap cryptocurrencies without the need for an intermediary like a centralized exchange. Instead, the DEX uses liquidity pools to facilitate trades. Liquidity pools are a collection of tokens locked in a smart contract that allows users to trade them without the need for a centralized order book.

When users want to trade a particular token, they can swap it for another token in the liquidity pool. The liquidity pool determines the price of the tokens based on the ratio of tokens in the pool. For example, if there is an equal amount of ETH and DAI in the pool, the price of 1 ETH would be equal to the price of 1 DAI.

When a user makes a swap, they pay a small fee, which is distributed to the liquidity providers who contribute to the pool. This fee incentivizes liquidity providers to add more tokens to the pool, which increases the liquidity and depth of the market.

As more people trade tokens in the liquidity pool, the price of the tokens can change based on the supply and demand dynamics of the market. When more people are buying a particular token, the price will increase, and when more people are selling a token, the price will decrease.

These price changes can create arbitrage opportunities for traders who can take advantage of price differences between different exchanges or liquidity pools. For example, if a token is trading at a higher price on Uniswap compared to another exchange, a trader could buy the token on the other exchange and sell it on Uniswap for a profit.

Overall, liquidity pools are a critical component of decentralized exchanges and allow for efficient and decentralized trading of cryptocurrencies. Understanding how they work can help traders take advantage of price differences and potentially profit from arbitrage opportunities.

Let's write some Solidity code for this.

// SPDX-License-Identifier: MI
pragma solidity ^0.8.0;

interface IERC20 {
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event Transfer(address indexed from, address indexed to, uint256 value);
}

contract UniswapLite {
    // Declare variables for token pairs, liquidity pools, and fees
    mapping(address => mapping(address => uint)) public pools;
    mapping(address => uint) public totalLiquidity;
    uint public fee = 300; // 0.3% fee
    address public owner;
    
    // Constructor function that sets the owner of the contract
    constructor() {
        owner = msg.sender;
    }

    // Function to add liquidity to a pool
    function addLiquidity(address tokenA, address tokenB, uint amountA, uint amountB) public {
        require(amountA > 0 && amountB > 0, "Amount must be greater than zero");
        require(pools[tokenA][tokenB] == 0, "Pool already exists");

        // Transfer tokens from the sender to the contract
        require(IERC20(tokenA).transferFrom(msg.sender, address(this), amountA), "Transfer failed");
        require(IERC20(tokenB).transferFrom(msg.sender, address(this), amountB), "Transfer failed");

        // Calculate liquidity and add to the pool
        uint liquidity = sqrt(amountA * amountB);
        pools[tokenA][tokenB] = liquidity;
        totalLiquidity[tokenA] += liquidity;
        totalLiquidity[tokenB] += liquidity;

        // Emit an event to notify that liquidity has been added to the pool
        emit AddLiquidity(msg.sender, tokenA, tokenB, amountA, amountB, liquidity);
    }
    // Function to remove liquidity from a pool
    function removeLiquidity(address tokenA, address tokenB, uint liquidity) public {
        require(pools[tokenA][tokenB] >= liquidity, "Insufficient liquidity");

        // Calculate amounts of tokens to be returned to the sender
        uint amountA = liquidity * IERC20(tokenA).balanceOf(address(this)) / totalLiquidity[tokenA];
        uint amountB = liquidity * IERC20(tokenB).balanceOf(address(this)) / totalLiquidity[tokenB];

        // Update liquidity and remove from the pool
        pools[tokenA][tokenB] -= liquidity;
        totalLiquidity[tokenA] -= liquidity;
        totalLiquidity[tokenB] -= liquidity;

        // Transfer tokens back to the sender
        require(IERC20(tokenA).transfer(msg.sender, amountA), "Transfer failed");
        require(IERC20(tokenB).transfer(msg.sender, amountB), "Transfer failed");

        // Emit an event to notify that liquidity has been removed from the pool
        emit RemoveLiquidity(msg.sender, tokenA, tokenB, amountA, amountB, liquidity);
    }
    // Function to swap tokens in a pool
    function swap(address tokenA, address tokenB, uint amountA) public {
        require(pools[tokenA][tokenB] > 0, "Pool does not exist");
        require(IERC20(tokenA).balanceOf(address(this)) >= amountA, "Insufficient balance");

        // Calculate the amount of token B to be received based on the ratio of the pool
        uint amountB = getAmountOut(tokenA, tokenB, amountA);

        // Transfer tokens from the sender to the contract
        require(IERC20(tokenA).transferFrom(msg.sender, address(this), amountA), "Transfer failed");

        // Transfer token B to the sender
        require(IERC20(tokenB).transfer(msg.sender, amountB), "Transfer failed");

        // Emit an event to notify that tokens have been swapped in the pool
        emit Swap(msg.sender, tokenA, tokenB, amountA, amountB);
    }

    // Function to get the amount of token B to be received based on the ratio of the pool
    function getAmountOut(address tokenA, address tokenB, uint amountA) public view returns (uint) {
        uint reserveA = IERC20(tokenA).balanceOf(address(this));
        uint reserveB = IERC20(tokenB).balanceOf(address(this));
        uint amountB = reserveB - reserveA * reserveB / (reserveA + amountA);
        return amountB;
    }

    // Function to get the amount of token A to be received based on the ratio of the pool
    function getAmountIn(address tokenA, address tokenB, uint amountB) public view returns (uint) {
        uint reserveA = IERC20(tokenA).balanceOf(address(this));
        uint reserveB = IERC20(tokenB).balanceOf(address(this));
        uint amountA = reserveA - reserveB * reserveA / (reserveB + amountB);
        return amountA;
    }
}        

The interface for ERC20 tokens defines the functions that a token must have in order to be used with this smart contract, such as transferFrom, transfer, approve, balanceOf, and allowance.

interface IERC20 {
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event Transfer(address indexed from, address indexed to, uint256 value);
}        

The mapping variables pools and totalLiquidity are used to store information about the liquidity pools created by users. The fee variable sets the percentage of fees that will be charged for trades.

The constructor function sets the owner of the contract to the address that deploys it.

mapping(address => mapping(address => uint)) public pools
mapping(address => uint) public totalLiquidity;
uint public fee = 300; // 0.3% fee
address public owner;

// Constructor function that sets the owner of the contract
constructor() {
    owner = msg.sender;
};        

The addLiquidity function takes four arguments: the addresses of the two tokens being added to the pool, and the amounts of each token being added. The function first checks that the amounts being added are greater than zero and that the pool does not already exist.

Then, the function transfers the tokens from the sender to the smart contract using the transferFrom function defined in the ERC20 interface.

Next, the function calculates the liquidity for the pool using the square root of the product of the two amounts being added. The liquidity is then added to the pool and the total liquidity for each token is updated.

The function emits an event to notify that liquidity has been added to the pool.

// Function to add liquidity to a poo
    function addLiquidity(address tokenA, address tokenB, uint amountA, uint amountB) public {
        require(amountA > 0 && amountB > 0, "Amount must be greater than zero");
        require(pools[tokenA][tokenB] == 0, "Pool already exists");

        // Transfer tokens from the sender to the contract
        require(IERC20(tokenA).transferFrom(msg.sender, address(this), amountA), "Transfer failed");
        require(IERC20(tokenB).transferFrom(msg.sender, address(this), amountB), "Transfer failed");

        // Calculate liquidity and add to the pool
        uint liquidity = sqrt(amountA * amountB);
        pools[tokenA][tokenB] = liquidity;
        totalLiquidity[tokenA] += liquidity;
        totalLiquidity[tokenB] += liquidity;

        // Emit an event to notify that liquidity has been added to the pool
        emit AddLiquidity(msg.sender, tokenA, tokenB, amountA, amountB, liquidity);
    }        

The removeLiquidity function takes three arguments: the addresses of the two tokens in the pool and the amount of liquidity being removed. The function first checks that there is enough liquidity in the pool to remove the requested amount.

Then, the function calculates the amounts of each token that will be returned to the sender based on the ratio of the liquidity in the pool to the total liquidity for each token.

Next, the function updates the liquidity for the pool and removes the requested liquidity. The function then transfers the tokens back to the sender using the transfer function defined in the ERC20 interface.

The function emits an event to notify that liquidity has been removed from the pool.

// Function to remove liquidity from a poo
    function removeLiquidity(address tokenA, address tokenB, uint liquidity) public {
        require(pools[tokenA][tokenB] >= liquidity, "Insufficient liquidity");

        // Calculate amounts of tokens to be returned to the sender
        uint amountA = liquidity * IERC20(tokenA).balanceOf(address(this)) / totalLiquidity[tokenA];
        uint amountB = liquidity * IERC20(tokenB).balanceOf(address(this)) / totalLiquidity[tokenB];

        // Update liquidity and remove from the pool
        pools[tokenA][tokenB] -= liquidity;
        totalLiquidity[tokenA] -= liquidity;
        totalLiquidity[tokenB] -= liquidity;

        // Transfer tokens back to the sender
        require(IERC20(tokenA).transfer(msg.sender, amountA), "Transfer failed");
        require(IERC20(tokenB).transfer(msg.sender, amountB), "Transfer failed");

        // Emit an event to notify that liquidity has been removed from the pool
        emit RemoveLiquidity(msg.sender, tokenA, tokenB, amountA, amountB, liquidity);
    }        

The swap function takes two arguments: the addresses of the two tokens in the pool and the amount of token A being swapped. The function first checks that the pool exists and that the contract has enough balance of token A.

// Function to swap tokens in a poo
    function swap(address tokenA, address tokenB, uint amountA) public {
        require(pools[tokenA][tokenB] > 0, "Pool does not exist");
        require(IERC20(tokenA).balanceOf(address(this)) >= amountA, "Insufficient balance");

        // Calculate the amount of token B to be received based on the ratio of the pool
        uint amountB = getAmountOut(tokenA, tokenB, amountA);

        // Transfer tokens from the sender to the contract
        require(IERC20(tokenA).transferFrom(msg.sender, address(this), amountA), "Transfer failed");

        // Transfer token B to the sender
        require(IERC20(tokenB).transfer(msg.sender, amountB), "Transfer failed");

        // Emit an event to notify that tokens have been swapped in the pool
        emit Swap(msg.sender, tokenA, tokenB, amountA, amountB);
    }l        

Then, the function calculates the amount of token B that will be received based on the ratio of the pool using the getAmountOut helper function. The function transfers token A from the sender to the contract using the transferFrom function, and transfers token B to the sender using the transfer function.

Finally, the function emits an event to notify that tokens have been swapped in the pool.

The getAmountOut and getAmountIn helper functions take three arguments: the addresses of the two tokens in the pool and either the amount of token A or the amount of token B being swapped. The functions calculate the amount of the other token that will be received based on the ratio of the pool. These functions are used by the swap function to calculate the amount of token B that will be received based on the amount of token A being swapped.

// Function to get the amount of token B to be received based on the ratio of the pool
function getAmountOut(address tokenA, address tokenB, uint amountA) public view returns (uint) {
    uint reserveA = IERC20(tokenA).balanceOf(address(this));
    uint reserveB = IERC20(tokenB).balanceOf(address(this));
    uint amountB = reserveB - reserveA * reserveB / (reserveA + amountA);
    return amountB;
}

// Function to get the amount of token A to be received based on the ratio of the pool
function getAmountIn(address tokenA, address tokenB, uint amountB) public view returns (uint) {
    uint reserveA = IERC20(tokenA).balanceOf(address(this));
    uint reserveB = IERC20(tokenB).balanceOf(address(this));
    uint amountA = reserveA - reserveB * reserveA / (reserveB + amountB);
    return amountA;
}        

Great! That's it!