protocol/0090-VAMM-automated_market_maker.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94be4268-65d7-49b6-8c37-40628437dc58",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from typing import Optional, Tuple, List\n",
    "from collections import namedtuple\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "955087ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "MMOrder = namedtuple(\"MMOrder\", [\"size\", \"price\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d91a510a-3fc5-46f7-a77e-971a4c1e3394",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CFMMarketMaker:\n",
    "    def __init__(\n",
    "        self,\n",
    "        initial_price: float = 100,\n",
    "        price_width_below: float = 0.05,\n",
    "        price_width_above: float = 0.05,\n",
    "        margin_multiple_at_upper: float = 2,\n",
    "        margin_multiple_at_lower: float = 2,\n",
    "        volume_per_side: float = 10,\n",
    "        num_levels: int = 25,\n",
    "        tick_spacing: float = 1,\n",
    "    ):\n",
    "        self.base_price = initial_price\n",
    "        self.upper_price = (1 + price_width_above) * initial_price\n",
    "        self.lower_price = (1 - price_width_below) * initial_price\n",
    "\n",
    "        self.base_price_sqrt = initial_price**0.5\n",
    "        self.upper_price_sqrt = self.upper_price**0.5\n",
    "        self.lower_price_sqrt = self.lower_price**0.5\n",
    "\n",
    "        self.lower_liq_factor = 1 / (self.base_price_sqrt - self.lower_price_sqrt)\n",
    "        self.upper_liq_factor = 1 / (self.upper_price_sqrt - self.base_price_sqrt)\n",
    "\n",
    "        self.margin_multiple_at_upper = margin_multiple_at_upper\n",
    "        self.margin_multiple_at_lower = margin_multiple_at_lower\n",
    "\n",
    "        self.tick_spacing = tick_spacing\n",
    "        self.num_levels = num_levels\n",
    "        self.volume_per_side = volume_per_side\n",
    "\n",
    "    def initialise(\n",
    "        self,\n",
    "        vega,\n",
    "    ):\n",
    "        risk_factors = vega.get_risk_factors(self.market_id)\n",
    "        self.short_factor, self.long_factor = risk_factors.short, risk_factors.long\n",
    "\n",
    "    def _quantity_for_move(\n",
    "        self,\n",
    "        start_price_sqrt,\n",
    "        end_price_sqrt,\n",
    "        range_upper_price_sqrt,\n",
    "        liquidity_factor,\n",
    "    ) -> Optional[float]:\n",
    "        if liquidity_factor == 0:\n",
    "            return None\n",
    "        start_fut_pos = (\n",
    "            liquidity_factor\n",
    "            * (range_upper_price_sqrt - start_price_sqrt)\n",
    "            / (start_price_sqrt * range_upper_price_sqrt)\n",
    "        )\n",
    "        end_fut_pos = (\n",
    "            liquidity_factor\n",
    "            * (range_upper_price_sqrt - end_price_sqrt)\n",
    "            / (end_price_sqrt * range_upper_price_sqrt)\n",
    "        )\n",
    "\n",
    "        return abs(start_fut_pos - end_fut_pos)\n",
    "\n",
    "    def _generate_shape(\n",
    "        self, bid_price_depth: float, ask_price_depth: float\n",
    "    ) -> Tuple[List[MMOrder], List[MMOrder]]:\n",
    "        return self._generate_shape_calcs(\n",
    "            balance=sum(\n",
    "                a.balance\n",
    "                for a in self.vega.get_accounts_from_stream(\n",
    "                    key_name=self.key_name,\n",
    "                    wallet_name=self.wallet_name,\n",
    "                    market_id=self.market_id,\n",
    "                )\n",
    "            ),\n",
    "            position=self.current_position,\n",
    "        )\n",
    "\n",
    "    def _quote_price(self,\n",
    "        balance: float,\n",
    "        position: float,\n",
    "        volume: float = 0\n",
    "    ):\n",
    "        \n",
    "        # volume_at_lower = (\n",
    "        #     balance * self.max_perc_loss_at_lower / (aep_lower - self.lower_price)\n",
    "        # )\n",
    "        # abs_volume_at_upper = (\n",
    "        #     balance * self.max_perc_loss_at_upper / (self.upper_price - aep_upper)\n",
    "        # )\n",
    "\n",
    "        # loss = volume_at_lower * (aep_lower - self.lower_price)\n",
    "        # margin = (volume_at_lower * self.lower_price) / (balance - loss)\n",
    "\n",
    "        # volume_at_lower = balance * loss_at_lower_perc / (aep_lower - self.lower_price)\n",
    "        # margin = (volume_at_lower * self.lower_price) / (balance - loss)\n",
    "\n",
    "        # volume_at_lower = margin * (balance - loss) / self.lower_price\n",
    "        # volume_at_lower = margin * (balance - volume_at_lower * (aep_lower - self.lower_price)) / self.lower_price\n",
    "        # volume_at_lower = - volume_at_lower * margin * ( aep_lower - self.lower_price) / self.lower_price + margin * balance / self.lower_price\n",
    "        # volume_at_lower (1 + margin * (aep_lower - self.lower_price) / self.lower_price) = margin * balance / self.lower_price\n",
    "        # volume_at_lower (self.lower_price (1 - margin) + margin * aep_lower) / self.lower_price = margin * balance / self.lower_price\n",
    "        # volume_at_lower = margin * balance / (self.lower_price (1 - margin) + margin * aep_lower)\n",
    "\n",
    "\n",
    "        # loss = abs_volume_at_upper * (self.upper_price - aep_upper)\n",
    "        # margin = (abs_volume_at_upper * self.upper_price) / (balance - loss)\n",
    "\n",
    "        # abs_volume_at_upper = margin * (balance - loss) / self.upper_price\n",
    "        # abs_volume_at_upper = margin * (balance - abs_volume_at_upper * (self.upper_price - aep_upper)) / self.upper_price\n",
    "\n",
    "        # abs_volume_at_upper = - abs_volume_at_upper * margin * (self.upper_price - aep_upper) / self.upper_price + margin * balance / self.upper_price\n",
    "\n",
    "        # abs_volume_at_upper (1 + margin * (self.upper_price - aep_upper) / self.upper_price) = margin * balance / self.upper_price\n",
    "\n",
    "        # abs_volume_at_upper (self.upper_price (1 + margin) - margin * aep_upper) / self.upper_price = margin * balance / self.upper_price\n",
    "        \n",
    "        # abs_volume_at_upper = margin * balance / (self.upper_price (1 + margin) - margin * aep_upper)\n",
    "\n",
    "        unit_upper_L = (\n",
    "            self.upper_price_sqrt\n",
    "            * self.base_price_sqrt\n",
    "            / (self.upper_price_sqrt - self.base_price_sqrt)\n",
    "        )\n",
    "\n",
    "        unit_lower_L = (\n",
    "            self.lower_price_sqrt\n",
    "            * self.base_price_sqrt\n",
    "            / (self.base_price_sqrt - self.lower_price_sqrt)\n",
    "        )\n",
    "        aep_lower = -1 * unit_lower_L * self.base_price_sqrt * ((unit_lower_L / (unit_lower_L + self.base_price_sqrt)) - 1)\n",
    "        aep_upper = -1 * unit_upper_L * self.upper_price_sqrt * ((unit_upper_L / (unit_upper_L + self.upper_price_sqrt)) - 1)\n",
    "\n",
    "        volume_at_lower = self.margin_multiple_at_lower * balance / (self.lower_price * (1 - self.margin_multiple_at_lower) + self.margin_multiple_at_lower * aep_lower)\n",
    "        volume_at_upper = self.margin_multiple_at_upper * balance / (self.upper_price * (1 + self.margin_multiple_at_upper) - self.margin_multiple_at_upper * aep_upper)\n",
    "        \n",
    "        upper_L = (\n",
    "            volume_at_upper\n",
    "            * self.upper_price_sqrt\n",
    "            * self.base_price_sqrt\n",
    "            / (self.upper_price_sqrt - self.base_price_sqrt)\n",
    "        )\n",
    "\n",
    "        lower_L = (\n",
    "            volume_at_lower\n",
    "            * self.lower_price_sqrt\n",
    "            * self.base_price_sqrt\n",
    "            / (self.base_price_sqrt - self.lower_price_sqrt)\n",
    "        )\n",
    "\n",
    "        if position > 0 or (position == 0 and volume > 0):\n",
    "            L = lower_L\n",
    "            upper_bound = self.base_price_sqrt\n",
    "            virt_x = position + L / upper_bound\n",
    "\n",
    "            rt_ref_price = upper_bound / (position * upper_bound / L + 1)\n",
    "            virt_y = L * rt_ref_price\n",
    "\n",
    "        else:\n",
    "            L = upper_L\n",
    "            upper_bound = self.upper_price_sqrt\n",
    "            virt_x = (volume_at_upper + position) + L / upper_bound\n",
    "            \n",
    "            rt_ref_price = upper_bound / ((volume_at_upper + position) * upper_bound / L + 1)\n",
    "            virt_y = L * rt_ref_price\n",
    "\n",
    "        if volume == 0:\n",
    "            return rt_ref_price ** 2\n",
    "        else:\n",
    "            out = (virt_y * virt_x) / (virt_x - volume) - virt_y\n",
    "            return out / volume\n",
    "\n",
    "    def _generate_shape_calcs(\n",
    "        self,\n",
    "        balance: float,\n",
    "        position: float,\n",
    "    ) -> Tuple[List[MMOrder], List[MMOrder]]:\n",
    "        unit_upper_L = (\n",
    "            self.upper_price_sqrt\n",
    "            * self.base_price_sqrt\n",
    "            / (self.upper_price_sqrt - self.base_price_sqrt)\n",
    "        )\n",
    "\n",
    "        unit_lower_L = (\n",
    "            self.lower_price_sqrt\n",
    "            * self.base_price_sqrt\n",
    "            / (self.base_price_sqrt - self.lower_price_sqrt)\n",
    "        )\n",
    "        aep_lower = -1 * unit_lower_L * self.base_price_sqrt * ((unit_lower_L / (unit_lower_L + self.base_price_sqrt)) - 1)\n",
    "        aep_upper = -1 * unit_upper_L * self.upper_price_sqrt * ((unit_upper_L / (unit_upper_L + self.upper_price_sqrt)) - 1)\n",
    "        \n",
    "        volume_at_lower = self.margin_multiple_at_lower * balance / (self.lower_price * (1 - self.margin_multiple_at_lower) + self.margin_multiple_at_lower * aep_lower)\n",
    "        volume_at_upper = self.margin_multiple_at_upper * balance / (self.upper_price * (1 + self.margin_multiple_at_upper) - self.margin_multiple_at_upper * aep_upper)\n",
    "        \n",
    "        upper_L = (\n",
    "            volume_at_upper\n",
    "            * self.upper_price_sqrt\n",
    "            * self.base_price_sqrt\n",
    "            / (self.upper_price_sqrt - self.base_price_sqrt)\n",
    "        )\n",
    "\n",
    "        lower_L = (\n",
    "            volume_at_lower\n",
    "            * self.lower_price_sqrt\n",
    "            * self.base_price_sqrt\n",
    "            / (self.base_price_sqrt - self.lower_price_sqrt)\n",
    "        )\n",
    "\n",
    "        if position > 0:\n",
    "            L = lower_L\n",
    "            upper_bound = self.base_price_sqrt\n",
    "            rt_ref_price = upper_bound / (position * upper_bound / L + 1)\n",
    "        else:\n",
    "            L = upper_L\n",
    "            upper_bound = self.upper_price_sqrt\n",
    "            rt_ref_price = upper_bound / ((volume_at_upper + position) * upper_bound / L + 1)\n",
    "\n",
    "\n",
    "        return self._calculate_price_levels(\n",
    "            ref_price=rt_ref_price ** 2,\n",
    "            balance=balance,\n",
    "            upper_L=upper_L,\n",
    "            lower_L=lower_L,\n",
    "            position=position,\n",
    "        )\n",
    "\n",
    "    def _calculate_liq_val(\n",
    "        self, margin_frac: float, balance: float, risk_factor: float, liq_factor: float\n",
    "    ) -> float:\n",
    "        return margin_frac * (balance / risk_factor) * liq_factor\n",
    "\n",
    "    def _calculate_price_levels(\n",
    "        self,\n",
    "        ref_price: float,\n",
    "        balance: float,\n",
    "        upper_L: float,\n",
    "        lower_L: float,\n",
    "        position: float,\n",
    "    ) -> Tuple[List[MMOrder], List[MMOrder]]:\n",
    "        if ref_price == 0:\n",
    "            ref_price = self.curr_price\n",
    "\n",
    "        agg_bids = []\n",
    "        agg_asks = []\n",
    "\n",
    "        pos = position\n",
    "\n",
    "        for i in range(1, self.num_levels):\n",
    "            pre_price_sqrt = (ref_price + (i - 1) * self.tick_spacing) ** 0.5\n",
    "            price = ref_price + i * self.tick_spacing\n",
    "\n",
    "            if price > self.upper_price or price < self.lower_price:\n",
    "                continue\n",
    "\n",
    "            volume = self._quantity_for_move(\n",
    "                pre_price_sqrt,\n",
    "                price**0.5,\n",
    "                self.upper_price_sqrt if pos < 0 else self.base_price_sqrt,\n",
    "                upper_L if pos < 0 else lower_L,\n",
    "            )\n",
    "            if volume is not None:\n",
    "                if pos > 0 and pos - volume < 0:\n",
    "                    volume = pos\n",
    "                agg_asks.append(MMOrder(volume, price))\n",
    "                pos -= volume\n",
    "\n",
    "        pos = position\n",
    "        for i in range(1, self.num_levels):\n",
    "            pre_price_sqrt = (ref_price - (i - 1) * self.tick_spacing) ** 0.5\n",
    "            price = ref_price - i * self.tick_spacing\n",
    "\n",
    "            if price > self.upper_price or price < self.lower_price:\n",
    "                continue\n",
    "\n",
    "            volume = self._quantity_for_move(\n",
    "                pre_price_sqrt,\n",
    "                price**0.5,\n",
    "                self.upper_price_sqrt if pos < 0 else self.base_price_sqrt,\n",
    "                upper_L if pos < 0 else lower_L,\n",
    "            )\n",
    "            if volume is not None:\n",
    "                if pos < 0 and pos + volume > 0:\n",
    "                    volume = pos\n",
    "                agg_bids.append(MMOrder(volume, price))\n",
    "                pos += volume\n",
    "\n",
    "        return agg_bids, agg_asks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60c5c97e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2cc483a",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\n",
    "mm = CFMMarketMaker(\n",
    "    initial_price=2000,\n",
    "    price_width_above=5,\n",
    "    price_width_below=0.99,\n",
    "    margin_multiple_at_lower=5,\n",
    "    margin_multiple_at_upper=5,\n",
    "    num_levels=8000,\n",
    "    tick_spacing=1,\n",
    ")\n",
    "\n",
    "balance = 100_000\n",
    "\n",
    "mm.short_factor = 0.02\n",
    "mm.long_factor = 0.02\n",
    "\n",
    "lower_L_unit = (\n",
    "    mm.base_price_sqrt\n",
    "    * mm.lower_price_sqrt\n",
    "    / (mm.base_price_sqrt - mm.lower_price_sqrt)\n",
    ")\n",
    "upper_L_unit = (\n",
    "    mm.base_price_sqrt\n",
    "    * mm.upper_price_sqrt\n",
    "    / (mm.upper_price_sqrt - mm.base_price_sqrt)\n",
    ")\n",
    "\n",
    "aep_lower = -1 * lower_L_unit * mm.base_price_sqrt * ((lower_L_unit / (lower_L_unit + mm.base_price_sqrt)) - 1)\n",
    "volume_at_lower = mm.margin_multiple_at_lower * balance / (mm.lower_price * (1 - mm.margin_multiple_at_lower) + mm.margin_multiple_at_lower * aep_lower)\n",
    "\n",
    "aep_upper = -1 * upper_L_unit * mm.upper_price_sqrt * ((upper_L_unit / (upper_L_unit + mm.upper_price_sqrt)) - 1)\n",
    "volume_at_upper = mm.margin_multiple_at_upper * balance / (mm.upper_price * (1 + mm.margin_multiple_at_upper) - mm.margin_multiple_at_upper * aep_upper)\n",
    "\n",
    "upper_L = (\n",
    "    volume_at_upper\n",
    "    * mm.upper_price_sqrt\n",
    "    * mm.base_price_sqrt\n",
    "    / (mm.upper_price_sqrt - mm.base_price_sqrt)\n",
    ")\n",
    "\n",
    "lower_L = (\n",
    "    volume_at_lower\n",
    "    * mm.base_price_sqrt\n",
    "    * mm.lower_price_sqrt\n",
    "    / (mm.base_price_sqrt - mm.lower_price_sqrt)\n",
    ")\n",
    "\n",
    "to_price = 3000\n",
    "pos = mm._quantity_for_move(\n",
    "    mm.base_price_sqrt,\n",
    "    to_price**0.5,\n",
    "    mm.base_price_sqrt if to_price < mm.base_price else mm.upper_price_sqrt,\n",
    "    lower_L if to_price < mm.base_price else upper_L,\n",
    ")\n",
    "\n",
    "print(\"Price is {}\".format(mm._quote_price(\n",
    "        balance=balance, position=0\n",
    "    ))\n",
    ")\n",
    "\n",
    "print(\"Position is {}\".format(pos))\n",
    "bids, asks = mm._generate_shape_calcs(\n",
    "    balance=balance, position=(-1 if to_price > mm.base_price else 1) * pos\n",
    ")\n",
    "\n",
    "# x = []\n",
    "# y = []\n",
    "\n",
    "# cumsum = 0\n",
    "# for bid in bids:\n",
    "#     x.append(bid.price)\n",
    "#     cumsum += bid.size\n",
    "#     y.append(cumsum)\n",
    "\n",
    "# plt.plot(x, y, color=\"blue\")\n",
    "x = []\n",
    "y = []\n",
    "\n",
    "# cumsum = 0\n",
    "# for ask in asks:\n",
    "#     x.append(ask.price)\n",
    "#     cumsum += ask.size\n",
    "#     y.append(cumsum)\n",
    "# plt.plot(x, y, color=\"red\")\n",
    "# plt.show()\n",
    "\n",
    "cumsum = 0\n",
    "for bid in bids:\n",
    "    x.append(bid.price)\n",
    "    cumsum += bid.size\n",
    "    y.append(bid.size)\n",
    "\n",
    "plt.bar(x, y, color=\"blue\")\n",
    "x = []\n",
    "y = []\n",
    "\n",
    "cumsum = 0\n",
    "for ask in asks:\n",
    "    x.append(ask.price)\n",
    "    cumsum += ask.size\n",
    "    y.append(ask.size)\n",
    "plt.ylim((0, 0.5))\n",
    "plt.bar(x, y, color=\"red\")\n",
    "\n",
    "print(f\"Mid is {(bids[0].price + asks[0].price) / 2 }\")\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d319c5bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "mm = CFMMarketMaker(\n",
    "    initial_price=2000,\n",
    "    price_width_above=5,\n",
    "    price_width_below=0.99,\n",
    "    margin_multiple_at_upper=0.8,\n",
    "    margin_multiple_at_lower=0.8,\n",
    "    num_levels=8000,\n",
    "    tick_spacing=1,\n",
    ")\n",
    "\n",
    "balance = 100_000\n",
    "\n",
    "mm.short_factor = 0.02\n",
    "mm.long_factor = 0.02\n",
    "\n",
    "fair = mm._quote_price(\n",
    "        balance=balance, position=0, volume = 0\n",
    ")\n",
    "\n",
    "single = mm._quote_price(\n",
    "        balance=balance, position=0, volume = 5\n",
    ")\n",
    "\n",
    "double = mm._quote_price(\n",
    "        balance=2 * balance, position=0, volume = 10\n",
    ")\n",
    "\n",
    "print(f\"f: {fair}, s: {single}, d: {double}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b37aa817",
   "metadata": {},
   "source": [
    "### Incoming AMM rebaselining"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8575603a",
   "metadata": {},
   "outputs": [],
   "source": [
    "existing_mm = CFMMarketMaker(\n",
    "    initial_price=2000,\n",
    "    price_width_above=0.1,\n",
    "    price_width_below=0.1,\n",
    "    margin_multiple_at_lower=0.1,\n",
    "    margin_multiple_at_upper=0.1,\n",
    "    num_levels=8000,\n",
    "    tick_spacing=1,\n",
    ")\n",
    "\n",
    "incoming_mm = CFMMarketMaker(\n",
    "    initial_price=2400,\n",
    "    price_width_above=5,\n",
    "    price_width_below=0.99,\n",
    "    margin_multiple_at_lower=2,\n",
    "    margin_multiple_at_upper=3,\n",
    "    num_levels=8000,\n",
    "    tick_spacing=1,\n",
    ")\n",
    "\n",
    "balance = 10_000\n",
    "existing_mm_balance = 10_000\n",
    "\n",
    "existing_mm.short_factor = 0.02\n",
    "existing_mm.long_factor = 0.02\n",
    "incoming_mm.short_factor = 0.02\n",
    "incoming_mm.long_factor = 0.02\n",
    "\n",
    "lower_L_unit = (\n",
    "    incoming_mm.base_price_sqrt\n",
    "    * incoming_mm.lower_price_sqrt\n",
    "    / (incoming_mm.base_price_sqrt - incoming_mm.lower_price_sqrt)\n",
    ")\n",
    "\n",
    "aep_lower = -1 * lower_L_unit * incoming_mm.base_price_sqrt * ((lower_L_unit / (lower_L_unit + incoming_mm.base_price_sqrt)) - 1)\n",
    "volume_at_lower = incoming_mm.margin_multiple_at_lower * balance / (incoming_mm.lower_price * (1 - incoming_mm.margin_multiple_at_lower) + incoming_mm.margin_multiple_at_lower * aep_lower)\n",
    "\n",
    "\n",
    "lower_L = (\n",
    "    volume_at_lower\n",
    "    * incoming_mm.base_price_sqrt\n",
    "    * incoming_mm.lower_price_sqrt\n",
    "    / (incoming_mm.base_price_sqrt - incoming_mm.lower_price_sqrt)\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c808160",
   "metadata": {},
   "outputs": [],
   "source": [
    "existing_mid = existing_mm._quote_price(existing_mm_balance, 0, 0)\n",
    "\n",
    "print(f\"Mid before is {existing_mid}\")\n",
    "\n",
    "to_rebaseline = incoming_mm._quantity_for_move(incoming_mm.base_price_sqrt, existing_mid**0.5, incoming_mm.base_price_sqrt, lower_L)\n",
    "\n",
    "print(f\"Rebaseline vol is {to_rebaseline}\")\n",
    "\n",
    "new_old_mid = incoming_mm._quote_price(balance, 0, 0)\n",
    "\n",
    "print(f\"mid for new was {new_old_mid}\")\n",
    "\n",
    "new_new_mid = incoming_mm._quote_price(balance, to_rebaseline, 0)\n",
    "\n",
    "print(f\"Now mid for new is {new_new_mid}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58aa874e",
   "metadata": {},
   "source": [
    "#### Ladder trading "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5dee9001",
   "metadata": {},
   "outputs": [],
   "source": [
    "existing_mm = CFMMarketMaker(\n",
    "    initial_price=2000,\n",
    "    price_width_above=0.1,\n",
    "    price_width_below=0.1,\n",
    "    margin_multiple_at_upper=0.6,\n",
    "    margin_multiple_at_lower=0.6,\n",
    "    num_levels=8000,\n",
    "    tick_spacing=1,\n",
    ")\n",
    "\n",
    "starting_pos = 0\n",
    "px = 2000\n",
    "balance = 8000\n",
    "posn = 0\n",
    "start_balance = balance\n",
    "\n",
    "step_size = 1\n",
    "\n",
    "lower_L = (\n",
    "    existing_mm.base_price_sqrt\n",
    "    * existing_mm.lower_price_sqrt\n",
    "    / (existing_mm.base_price_sqrt - existing_mm.lower_price_sqrt)\n",
    ")\n",
    "\n",
    "aep = -1 * lower_L * existing_mm.base_price_sqrt * ((lower_L / (lower_L + existing_mm.base_price_sqrt)) - 1)\n",
    "print(f\"aep is {aep}\")\n",
    "print(f\"Requested multiple at lower bound is {existing_mm.margin_multiple_at_lower}\")\n",
    "\n",
    "volume_at_lower = existing_mm.margin_multiple_at_lower * balance / (existing_mm.lower_price * (1 - existing_mm.margin_multiple_at_lower) + existing_mm.margin_multiple_at_lower * aep)\n",
    "\n",
    "average_trade = 0\n",
    "\n",
    "lower_L = (\n",
    "    volume_at_lower\n",
    "    * existing_mm.base_price_sqrt\n",
    "    * existing_mm.lower_price_sqrt\n",
    "    / (existing_mm.base_price_sqrt - existing_mm.lower_price_sqrt)\n",
    ")\n",
    "\n",
    "for i in range(1, 200):\n",
    "\n",
    "    to_rebaseline = existing_mm._quantity_for_move(px**0.5, (px-1)**0.5, existing_mm.base_price_sqrt, lower_L)\n",
    "    to_rebaseline_price = existing_mm._quote_price(start_balance, posn, -1 * to_rebaseline)\n",
    "\n",
    "    average_trade = (average_trade * posn + abs(to_rebaseline) * to_rebaseline_price) / (abs(to_rebaseline) + abs(posn))\n",
    "    px -= 1\n",
    "\n",
    "    balance -= posn * step_size\n",
    "\n",
    "    posn += to_rebaseline\n",
    "    print(f\"from {px + 1} to {px} takes volume {to_rebaseline} at price {to_rebaseline_price} with posn {posn} and balance {balance} average trade px {average_trade} implying leverage {posn * to_rebaseline_price / balance}\")\n",
    "\n",
    "print(f\"Loss is {start_balance - balance}\")\n",
    "\n",
    "for i in range(1, 200):\n",
    "\n",
    "    to_rebaseline = existing_mm._quantity_for_move(px**0.5, (px+step_size)**0.5, existing_mm.base_price_sqrt, lower_L)\n",
    "    to_rebaseline_price = existing_mm._quote_price(start_balance, posn, to_rebaseline)\n",
    "    px += step_size\n",
    "    balance += posn\n",
    "\n",
    "    posn -= to_rebaseline\n",
    "    print(f\"from {px + 1} to {px} takes volume {to_rebaseline} at price {to_rebaseline_price} with posn {posn} and balance {balance} average trade px {average_trade} implying leverage {posn * to_rebaseline_price / balance}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c475107d",
   "metadata": {},
   "outputs": [],
   "source": [
    "starting_pos = 0\n",
    "px = 2000\n",
    "start_balance = 1000\n",
    "balance = 1000\n",
    "posn = 0\n",
    "\n",
    "step_size = 1\n",
    "\n",
    "\n",
    "upper_L_unit = (\n",
    "        existing_mm.upper_price_sqrt\n",
    "        * existing_mm.base_price_sqrt\n",
    "        / (existing_mm.upper_price_sqrt - existing_mm.base_price_sqrt)\n",
    ")\n",
    "\n",
    "aep = -1 * upper_L_unit * existing_mm.upper_price_sqrt * ((upper_L_unit / (upper_L_unit + existing_mm.upper_price_sqrt)) - 1)\n",
    "print(f\"aep is {aep}\")\n",
    "print(f\"Requested multiple at upper bound is {existing_mm.margin_multiple_at_upper}\")\n",
    "\n",
    "volume_at_upper_incoming = existing_mm.margin_multiple_at_upper * balance / (existing_mm.upper_price * (1 + existing_mm.margin_multiple_at_upper) - existing_mm.margin_multiple_at_upper * aep)\n",
    "\n",
    "upper_L = (\n",
    "    volume_at_upper_incoming\n",
    "    * existing_mm.upper_price_sqrt\n",
    "    * existing_mm.base_price_sqrt\n",
    "    / (existing_mm.upper_price_sqrt - existing_mm.base_price_sqrt)\n",
    ")\n",
    "\n",
    "\n",
    "for i in range(1, 200):\n",
    "\n",
    "    to_rebaseline = existing_mm._quantity_for_move(px**0.5, (px+1)**0.5, existing_mm.upper_price_sqrt, upper_L)\n",
    "    to_rebaseline_price = existing_mm._quote_price(balance, posn, to_rebaseline)\n",
    "    px += 1\n",
    "\n",
    "    balance += posn * step_size\n",
    "    posn -= to_rebaseline\n",
    "\n",
    "    print(f\"from {px - 1} to {px} takes volume {to_rebaseline} at price {to_rebaseline_price} with posn {posn} and balance {balance} implying leverage {- posn * to_rebaseline_price / balance}\")\n",
    "\n",
    "print(\"Returning\")\n",
    "\n",
    "for i in range(1, 200):\n",
    "\n",
    "    to_rebaseline = existing_mm._quantity_for_move(px**0.5, (px+step_size)**0.5, existing_mm.upper_price_sqrt, upper_L)\n",
    "    to_rebaseline_price = existing_mm._quote_price(balance, posn, -1 * to_rebaseline)\n",
    "    px -= step_size\n",
    "    balance -= posn\n",
    "\n",
    "    posn += to_rebaseline\n",
    "    print(f\"from {px + 1} to {px} takes volume {to_rebaseline} at price {to_rebaseline_price} with posn {posn} and balance {balance} implying leverage {- posn * to_rebaseline_price / balance}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0e75a17",
   "metadata": {},
   "source": [
    "### Scenario Calculator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0dff6e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "upper_factor = 1300/1000 - 1\n",
    "lower_factor = 0.1\n",
    "base = 1000\n",
    "\n",
    "mm = CFMMarketMaker(\n",
    "    initial_price=base,\n",
    "    price_width_above=upper_factor,\n",
    "    price_width_below=lower_factor,\n",
    "    margin_multiple_at_upper=10,\n",
    "    margin_multiple_at_lower=1,\n",
    "    num_levels=8000,\n",
    "    tick_spacing=1,\n",
    ")\n",
    "\n",
    "starting_pos = 0\n",
    "balance = 10000\n",
    "posn = 0\n",
    "start_balance = balance\n",
    "\n",
    "unit_upper_L = (\n",
    "    mm.upper_price_sqrt\n",
    "    * mm.base_price_sqrt\n",
    "    / (mm.upper_price_sqrt - mm.base_price_sqrt)\n",
    ")\n",
    "\n",
    "unit_lower_L = (\n",
    "    mm.lower_price_sqrt\n",
    "    * mm.base_price_sqrt\n",
    "    / (mm.base_price_sqrt - mm.lower_price_sqrt)\n",
    ")\n",
    "aep_lower = -1 * unit_lower_L * mm.base_price_sqrt * ((unit_lower_L / (unit_lower_L + mm.base_price_sqrt)) - 1)\n",
    "aep_upper = -1 * unit_upper_L * mm.upper_price_sqrt * ((unit_upper_L / (unit_upper_L + mm.upper_price_sqrt)) - 1)\n",
    "\n",
    "volume_at_lower = mm.margin_multiple_at_lower * balance / (mm.lower_price * (1 - mm.margin_multiple_at_lower) + mm.margin_multiple_at_lower * aep_lower)\n",
    "volume_at_upper = mm.margin_multiple_at_upper * balance / (mm.upper_price * (1 + mm.margin_multiple_at_upper) - mm.margin_multiple_at_upper * aep_upper)\n",
    "\n",
    "loss_at_lower = volume_at_lower * (mm.lower_price - aep_lower)\n",
    "loss_at_upper = volume_at_upper * (mm.upper_price - aep_upper)\n",
    "\n",
    "print(f\"Position at lower would be {volume_at_lower} and position at upper would be {-1 * volume_at_upper}  (Lower AEP {aep_lower}, Upper AEP {aep_upper})\")\n",
    "print(f\"Implying leverage {volume_at_lower * mm.lower_price / (balance + loss_at_lower)} at lower and {volume_at_upper * mm.upper_price / (balance - loss_at_upper)} at upper\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2553a194",
   "metadata": {},
   "source": [
    "### Curve Estimator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aec95eb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "upper_factor = 1300/1000 - 1\n",
    "lower_factor = 0.1\n",
    "base = 1000\n",
    "\n",
    "mm = CFMMarketMaker(\n",
    "    initial_price=base,\n",
    "    price_width_above=upper_factor,\n",
    "    price_width_below=lower_factor,\n",
    "    margin_multiple_at_upper=10,\n",
    "    margin_multiple_at_lower=1,\n",
    "    num_levels=8000,\n",
    "    tick_spacing=1,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2fc7416",
   "metadata": {},
   "outputs": [],
   "source": [
    "trade_size = 100\n",
    "\n",
    "def execution_price(volume_to_trade: float, price_levels: list[(float, float)]):\n",
    "    '''First value in price_levels is price, second is volume\n",
    "    '''\n",
    "    weighted_execution_price = 0\n",
    "    traded_vol = 0\n",
    "    for level in price_levels:\n",
    "        if level[1] > volume_to_trade:\n",
    "            weighted_execution_price += volume_to_trade * level[0]\n",
    "            traded_vol += volume_to_trade\n",
    "            volume_to_trade = 0\n",
    "        else:\n",
    "            weighted_execution_price += level[1] * level[0]\n",
    "            volume_to_trade -= level[1]\n",
    "            traded_vol += level[1]\n",
    "        if volume_to_trade <= 0:\n",
    "            break\n",
    "    return weighted_execution_price / traded_vol\n",
    "\n",
    "def gen_levels(start_px: float, end_px: float, num_divisions: int, amm: CFMMarketMaker, amm_balance: float) -> list[(float, float)]:\n",
    "    last_level = start_px\n",
    "\n",
    "    unit_upper_L = (\n",
    "        amm.upper_price_sqrt\n",
    "        * amm.base_price_sqrt\n",
    "        / (amm.upper_price_sqrt - amm.base_price_sqrt)\n",
    "    )\n",
    "    aep = -1 * unit_upper_L * amm.upper_price_sqrt * ((unit_upper_L / (unit_upper_L + amm.upper_price_sqrt)) - 1)\n",
    "    volume_at_upper_incoming = amm.margin_multiple_at_upper * amm_balance / (amm.upper_price * (1 + amm.margin_multiple_at_upper) - amm.margin_multiple_at_upper * aep)\n",
    "\n",
    "    upper_L = (\n",
    "        volume_at_upper_incoming\n",
    "        * amm.upper_price_sqrt\n",
    "        * amm.base_price_sqrt\n",
    "        / (amm.upper_price_sqrt - amm.base_price_sqrt)\n",
    "    )\n",
    "\n",
    "    orders = []\n",
    "    for level in np.linspace(start_px, end_px, num=num_divisions):\n",
    "        if level == start_px:\n",
    "            continue\n",
    "        orders.append((level, amm._quantity_for_move(last_level**0.5, level**0.5, amm.upper_price_sqrt, upper_L)))\n",
    "        last_level = level\n",
    "    return orders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24a0ee68",
   "metadata": {},
   "outputs": [],
   "source": [
    "STEPS_IN_RANGE = 100\n",
    "RANGE_LOW = base\n",
    "RANGE_HIGH = 2 * RANGE_LOW\n",
    "TICK_SIZE = 0.01\n",
    "TRADE_SIZE = 100\n",
    "MM_BALANCE = 10_000\n",
    "\n",
    "num_divisions_to_test = [x for x in range(100, 10000, 5)]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9b009e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "prices = []\n",
    "\n",
    "for div in num_divisions_to_test:\n",
    "    levels = gen_levels(RANGE_LOW, RANGE_HIGH, div, mm, MM_BALANCE)\n",
    "    prices.append(execution_price(TRADE_SIZE, levels))\n",
    "\n",
    "plt.plot(num_divisions_to_test, prices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37264648",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}