# Build a DEX

Creating a decentralized exchange (DEX) like Uniswap using Ignite CLI involves several steps, including scaffolding the initial blockchain, creating a DEX module, and defining key functionalities like token pairs, liquidity pools, and swap mechanisms.

## Introduction

Creating a decentralized exchange (DEX) like Uniswap using Ignite CLI involves several steps, including scaffolding the initial blockchain, creating a DEX module, and defining key functionalities like token pairs, liquidity pools, and swap mechanisms.

## Prerequisites

- Basic understanding of blockchain and DEX principles.
- Ignite CLI installed.
- Familiarity with the Go programming language.

## Build the DEX Module

**Step 1: Scaffold the Blockchain**

First, create a new blockchain project:

ignite scaffold chain dexchain --no-module && cd dexchain

**Step 2: Scaffold the DEX Module**

ignite scaffold module dex

This command creates a new module named "dex".

**Step 3: Define Token Pairs and Liquidity Pool Structures**

ignite scaffold map tokenPair baseToken quoteToken --module dex
ignite scaffold map liquidityPool baseAmount quoteAmount totalShares --module dex

These structures represent the basic elements of your DEX: token pairs and liquidity pools.

## Step 4: Implement the Swap Logic

Create a message to handle token swaps:

ignite scaffold message swap baseToken quoteToken amount --module dex

We'll implement a simple version of the calculateSwapAmount function. Remember, these are just basic implementations and you would need to tailor them to fit the specific requirements and rules of your DEX.

In your `x/dex/keeper/msg_server_swap.go`, refine the logic for token swaps:

package keeper

import (
    "context"
    "errors"
    sdk "github.com/cosmos/cosmos-sdk/types"
    
    "dexchain/x/dex/types"
)

func (k msgServer) Swap(goCtx context.Context, msg *types.MsgSwap) (*types.MsgSwapResponse, error) {
    ctx := sdk.UnwrapSDKContext(goCtx)

    // Validate swap request
    if msg.Amount <= 0 {
        return nil, errors.New("swap amount must be positive")
    }

    // Retrieve the liquidity pool for the token pair
    liquidityPool, found := k.GetLiquidityPool(ctx, msg.BaseToken, msg.QuoteToken)
    if !found {
        return nil, errors.New("liquidity pool not found")
    }

    // Calculate swap amounts (simplified example)
    // Implement your own swap logic here, possibly involving a constant product formula, fees, etc.
    swapAmount := calculateSwapAmount(liquidityPool, msg.Amount)

    // Calculate swap amounts
    swapAmount, err := calculateSwapAmount(liquidityPool, msg.Amount)
    if err != nil {
        return nil, err
    }

    // Update liquidity pool balances
    // This is a simplified example. In a real scenario, you would need to adjust the pool's token balances.
    liquidityPool.BaseTokenBalance -= msg.Amount
    liquidityPool.QuoteTokenBalance += swapAmount
    k.SetLiquidityPool(ctx, liquidityPool)

    // Update user balances
    sender, err := sdk.AccAddressFromBech32(msg.Creator)
    if err != nil {
        return nil, err
    }

    // Deduct base tokens from sender
    err = k.bankKeeper.SendCoinsFromAccountToModule(ctx, sender, types.ModuleName, sdk.NewCoins(sdk.NewCoin(msg.BaseToken, sdk.NewInt(msg.Amount))))
    if err != nil {
        return nil, err
    }

    // Credit quote tokens to sender
    err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, sender, sdk.NewCoins(sdk.NewCoin(msg.QuoteToken, sdk.NewInt(swapAmount))))
    if err != nil {
        return nil, err
    }

    // Return response
    return &types.MsgSwapResponse{
        SwapAmount: swapAmount,
    }, nil
}

func calculateSwapAmount(liquidityPool types.LiquidityPool, amount int64) (int64, error) {
    // Implement your own swap logic here, possibly involving a constant product formula, fees, etc.
    // For example, using a constant product formula without fees:
    if liquidityPool.BaseTokenBalance <= 0 || liquidityPool.QuoteTokenBalance <= 0 {
        return 0, errors.New("invalid liquidity pool balances")
    }

    // Constant product formula: x * y = k
    k := liquidityPool.BaseTokenBalance * liquidityPool.QuoteTokenBalance
    newBaseTokenBalance := liquidityPool.BaseTokenBalance + amount
    newQuoteTokenBalance := k / newBaseTokenBalance
    swapAmount := liquidityPool.QuoteTokenBalance - newQuoteTokenBalance

    // Ensure swap amount is positive
    if swapAmount <= 0 {
        return 0, errors.New("swap amount must be positive")
    }

    return swapAmount, nil
}

In this enhanced Swap function, we:

- Validate the swap request to ensure the amount is positive.
- Calculate the swap amount using a simplified constant product formula.
- Update the liquidity pool balances accordingly.
- Deduct the base tokens from the sender's account and credit them to the module's account. The SendCoinsFromAccountToModule function handles this.
- Credit the quote tokens to the sender's account from the module's account using SendCoinsFromModuleToAccount.

The calculateSwapAmount function uses the constant product formula x * y = k for simplicity, where x and y are the token balances in the liquidity pool, and k is their product. When one token balance increases, the other decreases, maintaining the product k. This is a basic model and doesn't include considerations like transaction fees or slippage, which are important in real-world scenarios.

## Step 5: Liquidity Pool Management

Create messages to manage liquidity pools:

ignite scaffold message addLiquidity baseToken quoteToken amount --module dex
ignite scaffold message removeLiquidity poolId shares --module dex

**Add Liquidity**

In `x/dex/keeper/msg_server_add_liquidity.go`:

package keeper

import (
    "context"
    "errors"
    sdk "github.com/cosmos/cosmos-sdk/types"
    
    "dexchain/x/dex/types"
)

func (k Keeper) AddLiquidity(ctx sdk.Context, msg *types.MsgAddLiquidity) error {
    // Validate add liquidity request
    if msg.AmountBaseToken <= 0 || msg.AmountQuoteToken <= 0 {
        return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "amounts must be positive")
    }

    // Update liquidity pool balances
    pool, found := k.GetPool(ctx, msg.PoolName)
    if !found {
        return sdkerrors.Wrapf(types.ErrPoolNotFound, "pool %s not found", msg.PoolName)
    }

    pool.BaseTokenBalance += msg.AmountBaseToken
    pool.QuoteTokenBalance += msg.AmountQuoteToken
    k.SetPool(ctx, pool)

    // Issue liquidity pool shares to user
    shares := calculateLiquidityShares(msg.AmountBaseToken, msg.AmountQuoteToken)
    k.bankKeeper.MintCoins(ctx, types.ModuleName, sdk.NewCoins(sdk.NewCoin(types.PoolShareDenom, shares)))
    k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, msg.Creator, sdk.NewCoins(sdk.NewCoin(types.PoolShareDenom, shares)))

    return nil
}

// calculateLiquidityShares calculates the number of shares to mint based on the added liquidity.
func calculateLiquidityShares(amountBaseToken, amountQuoteToken int64, pool types.Pool) sdk.Int {
    if pool.BaseTokenBalance.IsZero() || pool.QuoteTokenBalance.IsZero() {
        // If the pool is empty, use a simple formula like 1 share per token unit
        return sdk.NewInt(amountBaseToken + amountQuoteToken)
    } else {
        // Calculate shares based on the ratio of added liquidity to existing pool liquidity
        totalLiquidity := pool.BaseTokenBalance.Add(pool.QuoteTokenBalance)
        addedLiquidity := sdk.NewInt(amountBaseToken + amountQuoteToken)
        return pool.Shares.Mul(addedLiquidity).Quo(totalLiquidity)
    }
}

**Remove Liquidity**

In `x/dex/keeper/msg_server_remove_liquidity.go`:

package keeper

import (
    "context"
    "errors"
    sdk "github.com/cosmos/cosmos-sdk/types"
    
    "dexchain/x/dex/types"
)

func (k Keeper) RemoveLiquidity(ctx sdk.Context, msg *types.MsgRemoveLiquidity) error {
    // Validate remove liquidity request
    // ...

    // Retrieve and update liquidity pool balances
    pool, found := k.GetPool(ctx, msg.PoolName)
    if !found {
        return sdkerrors.Wrapf(types.ErrPoolNotFound, "pool %s not found", msg.PoolName)
    }

    // Calculate the amount of base and quote tokens to return to the user
    baseTokenAmount, quoteTokenAmount := calculateTokenAmountsToRemove(pool, msg.Shares)

    pool.BaseTokenBalance -= baseTokenAmount
    pool.QuoteTokenBalance -= quoteTokenAmount
    k.SetPool(ctx, pool)

    // Burn liquidity pool shares and update user balances
    k.bankKeeper.BurnCoins(ctx, types.ModuleName, sdk.NewCoins(sdk.NewCoin(types.PoolShareDenom, msg.Shares)))
    k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, msg.Creator, sdk.NewCoins(sdk.NewCoin(types.BaseTokenDenom, baseTokenAmount), sdk.NewCoin(types.QuoteTokenDenom, quoteTokenAmount)))

    return nil
}

// calculateTokenAmountsToRemove calculates the amount of base and quote tokens to return based on the removed shares.
func calculateTokenAmountsToRemove(pool types.Pool, shares sdk.Int) (sdk.Int, sdk.Int) {
    totalShares := pool.Shares

    // Calculate the proportion of the pool that the shares represent
    shareRatio := shares.ToDec().Quo(totalShares.ToDec())

    // Calculate the amount of base and quote tokens to remove based on the share ratio
    baseTokenAmount := shareRatio.MulInt(pool.BaseTokenBalance).TruncateInt()
    quoteTokenAmount := shareRatio.MulInt(pool.QuoteTokenBalance).TruncateInt()

    return baseTokenAmount, quoteTokenAmount
}

These implementations involve:

- Validating liquidity addition and removal requests.
- Updating the liquidity pool balances in the blockchain's state.
- Issuing or burning liquidity pool shares.
- Updating the user's token balances accordingly.

Implement the logic for adding and removing liquidity in corresponding handler files

## Step 6: Interfacing with Bank Module

To handle token transfers, your DEX module will need to interface with the Cosmos SDK's bank module. Make sure your module has the necessary dependencies and permissions to interact with the bank module.

In your `x/dex/types/expected_keepers.go` add the following methods to the `BankKeeper`

	SendCoinsFromAccountToModule(ctx context.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) error
	SendCoinsFromModuleToModule(ctx context.Context, senderPool, recipientPool string, amt sdk.Coins) error
	BurnCoins(context.Context, []byte, sdk.Coins) error
	MintCoins(ctx context.Context, moduleName string, amt sdk.Coins) error

## Step 7: Testing and Launching Your DEX

Before launching, thoroughly test your DEX functionalities. Ensure all transactions, including swaps and liquidity management, work as expected.

## Conclusion

After following these steps, you will have a basic DEX module capable of handling token swaps and liquidity pool management. This tutorial serves as a starting point, and you can extend the module with more features like price oracles, advanced swap algorithms, or integration with other Cosmos SDK modules.