Liquidity Pool.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Liquidity Pools\n",
    "\n",
    "They keep the product constant and adjust the price(s) according to demand / supply."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "MRCT_Q = 50000\n",
    "ETH_Q = 50000\n",
    "\n",
    "K = MRCT_Q * ETH_Q\n",
    "\n",
    "mrct = float(MRCT_Q)\n",
    "eth = float(ETH_Q)\n",
    "\n",
    "mrct_p = 1.0\n",
    "eth_p = 1.0\n",
    "\n",
    "def printp():\n",
    "    print(f\"Pool :: MRCT ${mrct_p:.6} ({mrct:.6}), ETH ${eth_p:.6} ({eth:.6})\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "After setting the initial pool to have a constant value of 2.5BN (50k x 50k) we need to keep this balance.\n",
    "\n",
    "Assume someone wishes to BUY 1,000 MRCT tokens:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pool :: MRCT $1.02041 (49000.0), ETH $0.98 (51020.4)\n"
     ]
    }
   ],
   "source": [
    "mrct -= 1000\n",
    "eth = K / mrct\n",
    "\n",
    "mrct_p = MRCT_Q / mrct\n",
    "eth_p = ETH_Q / eth\n",
    "\n",
    "printp()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Now someone sells into the pool 2,500 ETH:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pool :: MRCT $1.06041 (47151.7), ETH $0.943033 (53020.4)\n"
     ]
    }
   ],
   "source": [
    "eth += 2000\n",
    "\n",
    "mrct = K / eth\n",
    "\n",
    "mrct_p = MRCT_Q / mrct\n",
    "eth_p = ETH_Q / eth\n",
    "\n",
    "printp()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "$2.5BN\n"
     ]
    }
   ],
   "source": [
    "# Pool value stays constant:\n",
    "print(f\"${eth_p * eth * mrct_p * mrct / 10**9:.2}BN\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "So, we arrive at the trading algo, where `sym` is the asset we want to trade (`ETH` or `MRCT`) and `qty` is how much of it want to buy from (negative) or sell into (positive) the pool:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "class Pool:\n",
    "    ETH = 'ETH'\n",
    "    MRCT = 'MRCT'\n",
    "    \n",
    "    def __init__(self, qty):\n",
    "        self.Q = qty\n",
    "        self.eth = self.mrct = self.Q\n",
    "        self.K = self.Q * self.Q\n",
    "        self.mrct_p = 1.0\n",
    "        self.eth_p = 1.0\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Pool :: MRCT ${self.mrct_p:.6f} ({self.mrct:.6f}), ETH ${self.eth_p:.6f} ({self.eth:.6f})\"\n",
    "\n",
    "    def trade(self, sym: str, qty: float):\n",
    "        value = 0\n",
    "        if sym == Pool.ETH:\n",
    "            self.eth += qty\n",
    "            desired = self.K / self.eth\n",
    "            diff = self.mrct - desired\n",
    "            if diff > 0:\n",
    "                print(f\"Emitting {diff:.5f} MRCTs\")\n",
    "            else:\n",
    "                print(f\"Requesting {-diff:.5f} MRCTs\")\n",
    "            self.mrct = desired\n",
    "            \n",
    "        elif sym == Pool.MRCT:\n",
    "            self.mrct += qty\n",
    "            desired = self.K / self.mrct\n",
    "            diff = self.eth - desired\n",
    "            if diff > 0:\n",
    "                print(f\"Emitting {diff:.5f} ETH\")\n",
    "            else:\n",
    "                print(f\"Requesting {-diff:.5f} ETH\")\n",
    "            self.eth = desired\n",
    "            \n",
    "        else:\n",
    "            raise RuntimeError(f\"Not a valid security: {sym}\")\n",
    "\n",
    "        self.mrct_p = self.Q / self.mrct\n",
    "        self.eth_p = self.Q / self.eth\n",
    "        return diff\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Emitting 967.74194 MRCTs\n",
      "Emitting 1759.53079 MRCTs\n",
      "Emitting 6342.49471 MRCTs\n",
      "Pool :: MRCT $1.433333 (20930.232558), ETH $0.697674 (43000.000000)\n",
      "We now have 9069.7674 MRCT, for a total value of $13000.0000\n"
     ]
    }
   ],
   "source": [
    "# Build a Pool with 30,000 each of ETH and MRCT:\n",
    "pool = Pool(30000)\n",
    "\n",
    "# We are \"pumping\" MRCT by flooding the pool with ETH\n",
    "mrct = 0\n",
    "mrct += pool.trade('ETH', 1000)\n",
    "mrct += pool.trade('ETH', 2000)\n",
    "mrct += pool.trade('ETH', 10000)\n",
    "\n",
    "print(f\"{pool}\")\n",
    "print(f\"We now have {mrct:.4f} MRCT, for a total value of ${mrct * pool.mrct_p:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "The ETH we used to flood the pool was bought (assuming parity) for USD13,000 so no gain was had, but if we had originally 10,000 MRCTs (worth $10,000) they are now worth:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14333.333333333334"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10000 * pool.mrct_p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "so we have made a \"gain\" of around 43%, which we can try to \"realize\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Emitting 13902.25564 ETH\n",
      "Pool :: MRCT $0.969925 (30930.232558), ETH $1.031008 (29097.744361)\n",
      "We now have 13902.2556 ETH, and 9069.7674 MRCT\n",
      "Their value is: $23130.3258\n"
     ]
    }
   ],
   "source": [
    "eth = pool.trade('MRCT', 10000)\n",
    "print(f\"{pool}\")\n",
    "print(f\"We now have {eth:.4f} ETH, and {mrct:.4f} MRCT\")\n",
    "print(f\"Their value is: ${eth*pool.eth_p + mrct*pool.mrct_p:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}