Scroll to top

DeFi Exchange (DEX) - Coming Soon

A Decentralized Exchange (DEX) is a blockchain-based platform that allows users to trade cryptocurrencies directly with each other without a centralized intermediary. Unlike traditional exchanges like Binance or Coinbase, a DEX operates through smart contracts and automated protocols, giving users full control over their funds and eliminating counterparty risk.

Key Features & Benefits

Non-Custodial Trading

Users retain ownership of their tokens in their wallets.
No need to deposit funds into exchange accounts, reducing risk of hacks or theft.

Automated Market Making (AMM)

Most DEXs use AMMs instead of order books.
Liquidity pools, funded by users, allow seamless token swaps using formulas like x × y = k, which automatically adjust prices based on supply and demand.

Global & Permissionless Access

Anyone with a crypto wallet can trade without KYC or account approvals.
DEXs operate 24/7 worldwide, enabling instant and borderless trading.

Lower Counterparty & Censorship Risk

No centralized authority can freeze assets or block trades.
Resistant to regulatory shutdowns and censorship, making it ideal for global users.

Incentivized Liquidity

Users who provide liquidity earn trading fees and sometimes governance tokens, creating a self-sustaining ecosystem.
This encourages deep liquidity and reduces slippage for traders.

Transparency & Security

All transactions are recorded on-chain, making them fully auditable.
Smart contracts enforce rules automatically, removing trust on intermediaries.

Use Cases

Token swapping for retail and institutional traders
Yield farming via liquidity provision
Launching new tokens without centralized listing requirements
Peer-to-peer trading in censorship-prone regions

Why DEX Matters

DEXs represent the core of decentralized finance (DeFi), offering a trustless, transparent, and permissionless alternative to centralized exchanges. By eliminating intermediaries, providing automated liquidity, and giving users full control, DEXs empower individuals to trade securely while participating in a growing, global, decentralized financial ecosystem.

DeFi Exchange (DEX) Protocol

DeFi Exchange (DEX)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

/*
---------------------------------------------------------
 Simple AMM DEX Prototype
 --------------------------------------------------------
 - Constant product formula: x * y = k
 - Liquidity providers earn fees
 - Non-custodial trading
---------------------------------------------------------
*/

interface IERC20 {
    function transfer(address to, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);

    function balanceOf(address user) external view returns (uint256);
}

/*
---------------------------------------------------------
 Main DEX Contract
---------------------------------------------------------
*/
contract SimpleDEX {

    IERC20 public tokenA;
    IERC20 public tokenB;

    uint256 public reserveA;
    uint256 public reserveB;

    uint256 public totalLiquidity;

    mapping(address => uint256) public liquidityOf;

    uint256 public constant FEE_BPS = 30; // 0.30%
    uint256 public constant BPS = 10_000;

    event LiquidityAdded(
        address indexed provider,
        uint256 amountA,
        uint256 amountB,
        uint256 liquidityMinted
    );

    event LiquidityRemoved(
        address indexed provider,
        uint256 amountA,
        uint256 amountB,
        uint256 liquidityBurned
    );

    event Swap(
        address indexed trader,
        address tokenIn,
        uint256 amountIn,
        address tokenOut,
        uint256 amountOut
    );

    constructor(IERC20 _tokenA, IERC20 _tokenB) {
        tokenA = _tokenA;
        tokenB = _tokenB;
    }

    /* -------------------------------------------------- */
    /*                LIQUIDITY LOGIC                     */
    /* -------------------------------------------------- */

    function addLiquidity(uint256 amountA, uint256 amountB) external {
        require(amountA > 0 && amountB > 0, "Zero amounts");

        tokenA.transferFrom(msg.sender, address(this), amountA);
        tokenB.transferFrom(msg.sender, address(this), amountB);

        uint256 liquidity;

        if (totalLiquidity == 0) {
            liquidity = _sqrt(amountA * amountB);
        } else {
            liquidity = _min(
                (amountA * totalLiquidity) / reserveA,
                (amountB * totalLiquidity) / reserveB
            );
        }

        require(liquidity > 0, "Insufficient liquidity minted");

        liquidityOf[msg.sender] += liquidity;
        totalLiquidity += liquidity;

        reserveA += amountA;
        reserveB += amountB;

        emit LiquidityAdded(msg.sender, amountA, amountB, liquidity);
    }

    function removeLiquidity(uint256 liquidity) external {
        require(liquidity > 0, "Zero liquidity");
        require(liquidityOf[msg.sender] >= liquidity, "Not enough");

        uint256 amountA = (liquidity * reserveA) / totalLiquidity;
        uint256 amountB = (liquidity * reserveB) / totalLiquidity;

        liquidityOf[msg.sender] -= liquidity;
        totalLiquidity -= liquidity;

        reserveA -= amountA;
        reserveB -= amountB;

        tokenA.transfer(msg.sender, amountA);
        tokenB.transfer(msg.sender, amountB);

        emit LiquidityRemoved(msg.sender, amountA, amountB, liquidity);
    }

    /* -------------------------------------------------- */
    /*                  SWAP LOGIC                        */
    /* -------------------------------------------------- */

    function swapAForB(uint256 amountIn) external {
        require(amountIn > 0, "Zero input");

        tokenA.transferFrom(msg.sender, address(this), amountIn);

        uint256 amountInWithFee =
            (amountIn * (BPS - FEE_BPS)) / BPS;

        uint256 amountOut =
            (reserveB * amountInWithFee) /
            (reserveA + amountInWithFee);

        require(amountOut > 0, "Zero output");

        tokenB.transfer(msg.sender, amountOut);

        reserveA += amountIn;
        reserveB -= amountOut;

        emit Swap(msg.sender, address(tokenA), amountIn, address(tokenB), amountOut);
    }

    function swapBForA(uint256 amountIn) external {
        require(amountIn > 0, "Zero input");

        tokenB.transferFrom(msg.sender, address(this), amountIn);

        uint256 amountInWithFee =
            (amountIn * (BPS - FEE_BPS)) / BPS;

        uint256 amountOut =
            (reserveA * amountInWithFee) /
            (reserveB + amountInWithFee);

        require(amountOut > 0, "Zero output");

        tokenA.transfer(msg.sender, amountOut);

        reserveB += amountIn;
        reserveA -= amountOut;

        emit Swap(msg.sender, address(tokenB), amountIn, address(tokenA), amountOut);
    }

    /* -------------------------------------------------- */
    /*                 VIEW HELPERS                       */
    /* -------------------------------------------------- */

    function getPriceAinB() external view returns (uint256) {
        return (reserveB * 1e18) / reserveA;
    }

    function getPriceBinA() external view returns (uint256) {
        return (reserveA * 1e18) / reserveB;
    }

    function getReserves() external view returns (uint256, uint256) {
        return (reserveA, reserveB);
    }

    /* -------------------------------------------------- */
    /*               MATH HELPERS                         */
    /* -------------------------------------------------- */

    function _min(uint256 x, uint256 y) internal pure returns (uint256) {
        return x < y ? x : y;
    }

    function _sqrt(uint256 y) internal pure returns (uint256 z) {
        if (y > 3) {
            z = y;
            uint256 x = y / 2 + 1;
            while (x < z) {
                z = x;
                x = (y / x + x) / 2;
            }
        } else if (y != 0) {
            z = 1;
        }
    }
}