QueueExchangeWithLPs-SafeMath.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Non-working attempt to make fixed point math safer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "import decimal\n",
    "from decimal import Decimal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Token:       \n",
    "    def __init__(self, _name = \"\"):\n",
    "        self.balances = {}\n",
    "        self.totalSupply = 0\n",
    "        self._name = _name\n",
    "    \n",
    "    def mint(self, address, amount):\n",
    "        assert(amount > 0)\n",
    "        self.balances[address] = self.balances.get(address, 0) + amount\n",
    "        self.totalSupply += amount\n",
    "        return True\n",
    "        \n",
    "    def burn(self, address, amount):\n",
    "        assert(amount > 0)\n",
    "        if self.balances[address] < amount:\n",
    "            raise Exception(\"burn: Cannot burn more value than present at address\")\n",
    "        self.balances[address] = self.balances.get(address, 0) - amount\n",
    "        self.totalSupply -= amount\n",
    "        return True\n",
    "    \n",
    "    def balanceOf(self, address):\n",
    "        return self.balances.get(address, 0)\n",
    "    \n",
    "    def name(self):\n",
    "        return self._name\n",
    "    \n",
    "    def transferFrom(self, sender, recipient, amount):\n",
    "        assert(amount >= 0)\n",
    "        # always round\n",
    "        if self.balanceOf(sender) >= amount:\n",
    "            self.balances[sender] = self.balances.get(sender, 0) - amount\n",
    "            self.balances[recipient] = self.balances.get(recipient, 0) + amount    \n",
    "            return True\n",
    "        else:\n",
    "            raise Exception(\"transferFrom: Cannot transfer more than balance\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Basic test of Token class\n",
    "\n",
    "token = Token()\n",
    "token.mint(\"A\", 5)\n",
    "assert(token.balanceOf(\"A\") == 5)\n",
    "\n",
    "token.transferFrom(\"A\", \"B\", 3)\n",
    "assert(token.balanceOf(\"B\") == 3)\n",
    "assert(token.balanceOf(\"A\") == 2)\n",
    "\n",
    "token.transferFrom(\"A\", \"C\", 2)\n",
    "assert(token.balanceOf(\"A\") == 0)\n",
    "assert(token.balanceOf(\"C\") == 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def assertNearly(first_value, second_value, msg, decimals=15):\n",
    "    assert(round(first_value, decimals) == round(second_value, decimals)) \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "assertNearly(1,1,\"ok\")\n",
    "#assertNearly(Decimal('1'),Decimal('2'),\"ok\")\n",
    "assertNearly(Decimal('1.01'),Decimal('1.02'),\"ok\", 1)\n",
    "#assertNearly(Decimal('1.01'),Decimal('1.02'),\"ok\", 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "decimal.getcontext().prec = 40\n",
    "decimal.getcontext().rounding = decimal.ROUND_DOWN\n",
    "\n",
    "def wad(number : Decimal):\n",
    "    return number.quantize(Decimal('0.000000000000000001'), rounding = decimal.ROUND_DOWN)\n",
    "\n",
    "def ray(number : Decimal):\n",
    "    return number.quantize(Decimal('0.000000000000000000000000001'), rounding = decimal.ROUND_DOWN)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert(wad(Decimal('0.001')) == Decimal('0.001'))\n",
    "assert(wad(Decimal('0.00000000000000000001')) == Decimal('0'))\n",
    "assert(wad(Decimal('0.000000000000000001')) == Decimal('0.000000000000000001'))\n",
    "assert(wad(Decimal('0.0000000000000000001')) != Decimal('0.0000000000000000001'))\n",
    "assert(ray(Decimal('0.0000000000000000000000000001')) == Decimal('0'))\n",
    "assert(ray(Decimal('0.000000000000000000000000001')) != Decimal('0'))\n",
    "assert(ray(Decimal('0.000000000000000000000000001')) == Decimal('0.000000000000000000000000001'))\n",
    "assert(ray(Decimal('0.000000000000000000000000001')) == Decimal('0.000000000000000000000000001'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time \n",
    "import decimal\n",
    "from decimal import Decimal \n",
    "math = decimal.Context()\n",
    "\n",
    "# class InterestToken\n",
    "#  __init__(rate, _rateAccumulator)\n",
    "#  balanceOfUnderlying(address)\n",
    "#  accrueInterest()\n",
    "#  updateRate(update)\n",
    "#  yearlyRate()\n",
    "\n",
    "class blockchain:\n",
    "    \n",
    "    def __init__(self, _timestamp, _block):\n",
    "        self.timestamp = _timestamp\n",
    "        self.block = _block\n",
    "    \n",
    "    def incrementBlock(self):\n",
    "        self.block += 1\n",
    "        self.timestamp += 15\n",
    "    \n",
    "    def updateTimestamp(self, _timestamp):\n",
    "        self.timestamp = _timestamp\n",
    "    \n",
    "    def now(self):\n",
    "        return self.timestamp\n",
    "\n",
    "\n",
    "class InterestToken(Token):\n",
    "    # rate is a yearly rate, converted to a rate compounded per second\n",
    "    def __init__(self, _name, _blockchain, rate, _rateAccumulator):\n",
    "        Token.__init__(self, _name)\n",
    "        self.blockchain = _blockchain\n",
    "        self.lastUpdate = self.blockchain.now()\n",
    "        self.rateAccumulator = _rateAccumulator\n",
    "        # 31622400 is the number of seconds in a year\n",
    "        self.rate = ray(math.power(1 + Decimal(rate), 1/Decimal(31622400)))\n",
    "        self.interestRateLimit = ray(math.power(1 + Decimal(2), 1/Decimal(31622400)))\n",
    "    \n",
    "    def balanceOfUnderlying(self, address):\n",
    "        return wad(self.balanceOf(address) * self.rateAccumulator)\n",
    "    \n",
    "    def transferUnderlying(self, sender, recipient, amount):\n",
    "        value = wad(amount / self.rateAccumulator)\n",
    "        return self.transferFrom(sender, recipient, value)\n",
    "        \n",
    "    def accrueInterest(self):\n",
    "        now = self.blockchain.now()\n",
    "        if now > self.lastUpdate:\n",
    "            total_time =  now - self.lastUpdate\n",
    "            self.rateAccumulator = ray(math.power(self.rate, total_time) * self.rateAccumulator)\n",
    "            self.lastUpdate = now\n",
    "    \n",
    "    def updateRate(self, update):\n",
    "        newRate = ray(math.power(1 + Decimal(update), 1/Decimal(31622400)) - 1)\n",
    "        self.rate = self.rate + newRate\n",
    "        if self.rate < Decimal(1):\n",
    "            self.rate = Decimal(1)\n",
    "        if self.rate > self.interestRateLimit:\n",
    "            self.rate = self.interestRateLimit\n",
    "    \n",
    "    def yearlyRate(self):\n",
    "        return round(math.power(self.rate, Decimal(31622400)) - 1, 4)\n",
    "    \n",
    "    def mintInUnderlying(self, address, amount):\n",
    "        self.mint(address, amount/self.rateAccumulator)\n",
    "        \n",
    "    def burnInUnderlying(self, address, amount):\n",
    "        self.burn(address, amount/self.rateAccumulator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Basic tests of Interest Token Class\n",
    "\n",
    "chain = blockchain(0,1)\n",
    "token = InterestToken(\"Token\", chain, .02, 1)\n",
    "token.mint(\"A\", 1000)\n",
    "#token.lastUpdate = token.lastUpdate - 31622400\n",
    "chain.updateTimestamp(31622400)\n",
    "token.accrueInterest()\n",
    "token.balanceOfUnderlying(\"A\")\n",
    "assert(int(token.balanceOfUnderlying(\"A\")) == 1020)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "chain = blockchain(0,1)\n",
    "token = InterestToken(\"Token\", chain, .02, 1)\n",
    "token.mint(\"A\", 1000)\n",
    "#token.lastUpdate = token.lastUpdate - 31622400\n",
    "# Note that the per second rates are multiplied, not added\n",
    "token.updateRate(.001)\n",
    "token.updateRate(.001)\n",
    "token.updateRate(-.001)\n",
    "token.updateRate(.001)\n",
    "token.updateRate(.001)\n",
    "#print(token.yearlyRate())\n",
    "chain.updateTimestamp(31622400)\n",
    "#print(token.rate)\n",
    "token.accrueInterest()\n",
    "assert(int(token.balanceOfUnderlying(\"A\")) == 1023)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "chain = blockchain(1,1)\n",
    "uToken = InterestToken(\"Token\", chain, .04, 1)\n",
    "for x in range(10000):\n",
    "    chain.incrementBlock()\n",
    "    uToken.accrueInterest()\n",
    "\n",
    "#uToken.rateAccumulator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "class QueueExchange(Token):\n",
    "    def __init__(self, _token, _uToken : Token , _sToken : InterestToken):\n",
    "        super().__init__(_token)\n",
    "        self.uToken = _uToken\n",
    "        self.sToken = _sToken\n",
    "        self.underlying = Decimal('0')\n",
    "        self.synthetic  = Decimal('0')\n",
    "        self.address = '0x' + _token\n",
    "        self.book = {}\n",
    "        self.uTokenBalance = Decimal('0')\n",
    "        self.sTokenBalance = Decimal('0')\n",
    "        self.sTokenBalanceUnderlying = Decimal('0')\n",
    "        self.conversionRate = Decimal('1')\n",
    "        self.savedRateAccumulator = self.sToken.rateAccumulator\n",
    "        self.fee = Decimal('0.0005')\n",
    "        \n",
    "        \n",
    "    # This proxy function lets us add logic to transfers if needed later\n",
    "    def transferToken(self, token, sender, recipient, amount):\n",
    "        assert(self.uTokenBalance >= 0)\n",
    "        assert(self.sTokenBalance >= 0)\n",
    "        if token == self.sToken:\n",
    "            return token.transferUnderlying(sender, recipient, amount)\n",
    "        else:\n",
    "            return token.transferFrom(sender, recipient, amount)\n",
    "    \n",
    "    def balanceOfUnderlying(self, address):\n",
    "        return wad(self.balanceOf(address) * self.conversionRate)\n",
    "    \n",
    "    # Before changing the self.totalSupply of the Liquidity Provisioning shares, \n",
    "    # we must make sure we update the self.conversionRate \n",
    "    # self.totalSupply is not changed by adding accumulated interest\n",
    "    def collectSyntheticInterest(self):\n",
    "        if self.totalSupply == 0:\n",
    "            return True\n",
    "        # calculate interest earned\n",
    "        print(\"sTokenBalance: {} rateAccumulator: {} saveRateAccumulator: {}\".format(self.sTokenBalance, self.sToken.rateAccumulator, self.savedRateAccumulator))\n",
    "        interestEarned = ray(self.sTokenBalance * (self.sToken.rateAccumulator - self.savedRateAccumulator))     \n",
    "        assert(interestEarned >= 0)\n",
    "        # interest is shared across all users\n",
    "        newTotalValue = wad((self.totalSupply * self.conversionRate)  + interestEarned)\n",
    "        oldConversionRate = self.conversionRate\n",
    "        self.conversionRate = ray(newTotalValue / self.totalSupply)\n",
    "        # update \n",
    "        self.savedRateAccumulator = self.sToken.rateAccumulator\n",
    "        self.sTokenBalanceUnderlying = self.sTokenBalanceUnderlying + interestEarned\n",
    "        \n",
    "        # check that coversionRate is strictly increasing\n",
    "        if self.conversionRate < oldConversionRate:\n",
    "            raise Exception(\"collectSyntheticInterest: conversionRate decreased, somehow old: {} new: {}\".format(oldConversionRate, self.conversionRate))\n",
    "        \n",
    "        # check sToken balance invariant\n",
    "        try:\n",
    "            assert(round(self.sTokenBalanceUnderlying,18) == round(self.sTokenBalance*self.sToken.rateAccumulator, 18))\n",
    "        except:\n",
    "            raise Exception(\"collectSyntheticInterest: sToken balance mismatch sTokenBalanceUnderlying:{} sTokenBalance:{} conversionRate:{}\".format(self.sTokenBalanceUnderlying, self.sTokenBalance, self.conversionRate))\n",
    "        \n",
    "        # fail if our accounting of balance does not match true balance\n",
    "        # this cannot be done in Solidity as transfers can be sent without contracts consent\n",
    "        try:\n",
    "            assert(round(self.sTokenBalanceUnderlying,18) == round(self.sToken.balanceOfUnderlying(self.address), 18))\n",
    "        except:\n",
    "            print(\"sTokenBalanceUnderlying {} does not equal balanceOfUnderlying {} \".format(self.sTokenBalanceUnderlying,self.sToken.balanceOfUnderlying(self.address))\n",
    "                 ) \n",
    "            print(\"balanceOf: {} rateAccumulator: {}\".format(self.sToken.balanceOf(self.address), self.sToken.rateAccumulator))\n",
    "            print(\"interestEarned: {} newTotalValue: {}\".format(interestEarned, newTotalValue))\n",
    "            pass\n",
    "        return\n",
    "        \n",
    "    def depositUnderlying(self, address, amount):\n",
    "        if amount > 0:\n",
    "            # before updating, collect interest\n",
    "            self.collectSyntheticInterest()\n",
    "            result = self.transferToken(self.uToken, address, self.address, amount)\n",
    "            if not result:\n",
    "                raise Exception('depositUnderlying: Transfer Failed')\n",
    "            self.uTokenBalance += amount\n",
    "            self.balances[address] = self.balances.get(address, 0) + wad(amount/self.conversionRate)\n",
    "            self.totalSupply += wad(amount/self.conversionRate)\n",
    "            return True\n",
    "        else:\n",
    "            raise Exception(\"depositUnderlying: Cannot deposit zero or negative funds\")\n",
    "        \n",
    "    # Deposit synthetic. Amount is denominated in underlying\n",
    "    def depositSynthetic(self, address, amount):\n",
    "        if amount > 0:        \n",
    "            # before updating, collect interest\n",
    "            self.collectSyntheticInterest()\n",
    "            #Transfer synthetic\n",
    "            result = self.transferToken(self.sToken, address, self.address, amount)\n",
    "            if not result:\n",
    "                raise Exception('depositUnderlying: Transfer Failed')\n",
    "            self.sTokenBalance += wad(amount / self.sToken.rateAccumulator)\n",
    "            self.sTokenBalanceUnderlying += amount\n",
    "            self.balances[address] = self.balances.get(address, 0) + wad(amount/self.conversionRate)\n",
    "            self.totalSupply += wad(amount/self.conversionRate)\n",
    "            return True\n",
    "        else:\n",
    "            raise Exception(\"depositUnderlying: Cannot deposit zero or negative funds\")\n",
    "    \n",
    "    # withdraw underlying token using underlying token as unit of account \n",
    "    def withdrawUnderlying(self, address, amount):\n",
    "        if amount > 0:\n",
    "            # before updating, collect interest\n",
    "            self.collectSyntheticInterest()\n",
    "            #check if funds are sufficient\n",
    "            if amount > self.balanceOfUnderlying(address):\n",
    "                raise Exception(\"withdrawUnderlying: Cannot withdraw more than balance Requested {}, Available {}\".format(amount, self.balances.get(address, 0) * self.conversionRate))\n",
    "            # Is there enough balance to send?\n",
    "            if amount > self.uTokenBalance:\n",
    "                raise Exception(\"withdrawUnderlying: Insufficient balance in exchange\")\n",
    "            self.balances[address] -= wad(amount/self.conversionRate)\n",
    "            # when withdrawing underlying, a fee is taken\n",
    "            fee = amount * self.fee\n",
    "            amountMinusFee = amount - fee\n",
    "            newTotalValue = wad((self.totalSupply * self.conversionRate)  - amountMinusFee)\n",
    "            self.totalSupply -= wad(amount/self.conversionRate)\n",
    "            self.uTokenBalance -= amountMinusFee\n",
    "            self.conversionRate = wad(newTotalValue / self.totalSupply)\n",
    "            return self.transferToken(self.uToken, self.address, address, amountMinusFee)\n",
    "        else:\n",
    "            raise Exception(\"withdrawUnderlying: Cannot withdraw zero or negative tokens\")\n",
    "    \n",
    "    def maxUnderlying(self):\n",
    "        return min(self.uToken.balanceOf(self.address), self.uTokenBalance)\n",
    "    \n",
    "    def maxSynthetic(self):\n",
    "        return min(self.sToken.balanceOfUnderlying(self.address), self.sTokenBalanceUnderlying)\n",
    "        \n",
    "    \n",
    "    # withdraw synthetic token using underlying token as unit of account\n",
    "    def withdrawSynthetic(self, address, amount):\n",
    "        if amount > 0:\n",
    "            # before updating, collect interest\n",
    "            self.collectSyntheticInterest()\n",
    "            #check if funds are sufficient\n",
    "            if amount > self.balances.get(address, 0) * self.conversionRate:\n",
    "                raise Exception(\"withdrawSynthetic: Cannot withdraw more than balance Requested {}, Available {}\".format(amount, self.balances.get(address, 0) * self.conversionRate))\n",
    "            # Is there enough balance to send?\n",
    "            if amount > self.sTokenBalanceUnderlying:\n",
    "                raise Exception(\"withdrawSynthetic: Insufficient balance in exchange. Requested {}, Available {}\".format(amount, self.sTokenBalanceUnderlying))\n",
    "            # Double check by checking balance of synthetic\n",
    "            if amount > self.sToken.balanceOfUnderlying(self.address):\n",
    "                raise Exception(\"withdrawSynthetic: Insufficient balance in exchange. Requested {}, Available {}\".format(amount, self.sToken.balanceOfUnderlying(self.address)))\n",
    "            self.balances[address] -= amount/self.conversionRate\n",
    "            self.totalSupply -= amount/self.conversionRate\n",
    "            self.sTokenBalance -= amount / self.sToken.rateAccumulator\n",
    "            self.sTokenBalanceUnderlying -= amount\n",
    "            return self.transferToken(self.sToken, self.address, address, amount)\n",
    "        else:\n",
    "            raise Exception(\"withdrawSynthetic: Cannot withdraw zero or negative tokens\")\n",
    "    \n",
    "    def measureImbalance(self):\n",
    "        self.collectSyntheticInterest()\n",
    "        # If balance difference is under 5% of the total, treat as if there is no imbalance \n",
    "        if self.totalSupply == 0:\n",
    "            return Decimal('0')\n",
    "        if abs(Decimal(self.uTokenBalance - self.sTokenBalanceUnderlying) / Decimal(self.totalSupply * self.conversionRate)) < Decimal('0.5'):\n",
    "            return Decimal('0')\n",
    "        return self.uTokenBalance - self.sTokenBalanceUnderlying\n",
    "    \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sTokenBalance: 0 rateAccumulator: 1 saveRateAccumulator: 1\n",
      "sTokenBalance: 1000.000000000000000000 rateAccumulator: 1.039999998710106074983596066 saveRateAccumulator: 1\n"
     ]
    },
    {
     "ename": "InvalidOperation",
     "evalue": "[<class 'decimal.InvalidOperation'>]",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mInvalidOperation\u001b[0m                          Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-45-9370d6120d94>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0muToken\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"C\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mDecimal\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'1000'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0msToken\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maccrueInterest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m \u001b[0mqx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdepositUnderlying\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"C\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mDecimal\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'1000'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     15\u001b[0m \u001b[0mqx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwithdrawSynthetic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"C\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mqx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbalanceOfUnderlying\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"C\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-44-71b390e44ac2>\u001b[0m in \u001b[0;36mdepositUnderlying\u001b[0;34m(self, address, amount)\u001b[0m\n\u001b[1;32m     71\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mamount\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m             \u001b[0;31m# before updating, collect interest\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 73\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcollectSyntheticInterest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     74\u001b[0m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransferToken\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muToken\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maddress\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maddress\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mamount\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     75\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-44-71b390e44ac2>\u001b[0m in \u001b[0;36mcollectSyntheticInterest\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     36\u001b[0m         \u001b[0;31m# calculate interest earned\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     37\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"sTokenBalance: {} rateAccumulator: {} saveRateAccumulator: {}\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msTokenBalance\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msToken\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrateAccumulator\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msavedRateAccumulator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 38\u001b[0;31m         \u001b[0minterestEarned\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msTokenBalance\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msToken\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrateAccumulator\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msavedRateAccumulator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     39\u001b[0m         \u001b[0;32massert\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minterestEarned\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     40\u001b[0m         \u001b[0;31m# interest is shared across all users\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-27-ae42065e5848>\u001b[0m in \u001b[0;36mray\u001b[0;34m(number)\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumber\u001b[0m \u001b[0;34m:\u001b[0m \u001b[0mDecimal\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mround\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumber\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m27\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mInvalidOperation\u001b[0m: [<class 'decimal.InvalidOperation'>]"
     ]
    }
   ],
   "source": [
    "# Some basic testing of QX\n",
    "chain = blockchain(1,1)\n",
    "uToken = Token(\"Token\")\n",
    "uToken.mint(\"A\", Decimal('1000'))\n",
    "sToken = InterestToken(\"pyToken\", chain, Decimal('.04'), Decimal('1'))\n",
    "sToken.mint(\"B\", Decimal('1000'))\n",
    "qx = QueueExchange(\"QX\", uToken, sToken)\n",
    "qx.depositUnderlying(\"A\", Decimal('1000'))\n",
    "qx.depositSynthetic(\"B\", Decimal('1000'))\n",
    "#Add in some interest\n",
    "chain.updateTimestamp(31622400)\n",
    "uToken.mint(\"C\", Decimal('1000'))\n",
    "sToken.accrueInterest()\n",
    "qx.depositUnderlying(\"C\", Decimal('1000'))\n",
    "qx.withdrawSynthetic(\"C\", qx.balanceOfUnderlying(\"C\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [],
   "source": [
    "chain = blockchain(1,1)\n",
    "uToken = Token(\"Token\")\n",
    "uToken.mint(\"A\", Decimal('1000'))\n",
    "sToken = InterestToken(\"pyToken\", chain, Decimal('.04'), Decimal('1'))\n",
    "sToken.mint(\"B\", Decimal('1000'))\n",
    "qx = QueueExchange(\"QX\", uToken, sToken)\n",
    "qx.depositUnderlying(\"A\", Decimal('1000'))\n",
    "qx.depositSynthetic(\"B\", Decimal('1000'))\n",
    "chain.updateTimestamp(31622400)\n",
    "sToken.accrueInterest()\n",
    "qx.collectSyntheticInterest()\n",
    "# Half underlying, Half pyToken means half the total interest rate\n",
    "assert(qx.conversionRate == Decimal('1.019999999355053037491798033'))\n",
    "qx.withdrawUnderlying(\"B\", 500)\n",
    "assert(qx.conversionRate == Decimal('1.020165583770671446317224349'))\n",
    "qx.withdrawSynthetic(\"A\", 500)\n",
    "chain.updateTimestamp(2 * 31622400)\n",
    "sToken.accrueInterest()\n",
    "qx.collectSyntheticInterest()\n",
    "assert(uToken.balanceOf(\"0xQX\") + sToken.balanceOfUnderlying(\"0xQX\") - \\\n",
    "       (qx.conversionRate * qx.totalSupply) < Decimal('0.000000000000000001'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Oracle:\n",
    "    def __init__(self, _tokenA, _tokenB):\n",
    "        self.tokenA = _tokenA\n",
    "        self.tokenB = _tokenB\n",
    "        # Price is stored in terms of TokenB\n",
    "        self.price = 0 \n",
    "    \n",
    "    # Assumes price is in terms of Token B\n",
    "    def currentPrice(self):\n",
    "        return self.price\n",
    "    \n",
    "    # Assumes price is in terms of Token B\n",
    "    def setPrice(self, price):\n",
    "        self.price = price\n",
    "        \n",
    "    def setPriceInToken(self, token, price):\n",
    "        if token == self.tokenA:\n",
    "            self.price = 1 / price\n",
    "        else:\n",
    "            self.price = price\n",
    "            \n",
    "    def getPriceInToken(self, token):\n",
    "        if token == self.tokenA:\n",
    "            return Decimal('1') /self.price\n",
    "        else:     \n",
    "            return self.price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simple Test of Oracle\n",
    "ETH = Token(\"ETH\")\n",
    "DAI = Token(\"DAI\")\n",
    "oracle = Oracle(ETH, DAI)\n",
    "oracle.setPriceInToken(DAI, Decimal('100'))\n",
    "assert(oracle.getPriceInToken(DAI) == Decimal('100'))\n",
    "assert(oracle.getPriceInToken(ETH) == (Decimal('1')/Decimal('100')))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {},
   "outputs": [],
   "source": [
    "class pyToken (InterestToken):\n",
    "    def __init__(self, _blockchain, _underlying : Token, _oracle):  \n",
    "        super().__init__(\"\", _blockchain, Decimal('0'), Decimal('1'))\n",
    "        self.underlying = _underlying\n",
    "        self._name = \"py\" + self.underlying.name()\n",
    "        self.cdp = {self.underlying.name(): {}}\n",
    "        self.tokens = {}\n",
    "        self.address = '0x' + self.name()\n",
    "        # oracle for the pyToken <> pyToken pair\n",
    "        self.oracle = _oracle\n",
    "        self.qx = 0\n",
    "        self.interestUpdateAmount = Decimal('0.0001')\n",
    "        self.collateralizationRatio = Decimal('1.7')\n",
    "        self.debtAccumulator = self.rateAccumulator\n",
    "        self.debtRate = self.rate\n",
    "        # bonus factor when liquidating\n",
    "        self.bonus = Decimal('1.1')\n",
    "        \n",
    "    # Admin Functions\n",
    "    def setPair(self, _pairedpyToken : InterestToken):\n",
    "        self.pairedpyToken = _pairedpyToken  \n",
    "        self.tokens[self.pairedpyToken.name()] = self.pairedpyToken\n",
    "        self.cdp[self.pairedpyToken.name()] = {}\n",
    "        \n",
    "    def setQueueExchange(self,exchange):\n",
    "        self.qx = exchange\n",
    "        \n",
    "    def addCollateralType(self, token, oracle):\n",
    "        self.tokens[token.name()] = { 'token':token, 'oracle':oracle }\n",
    "        self.cdp[token.name()] = {}\n",
    "    \n",
    "    # User Functions\n",
    "    def addCollateral(self, token, address, amount):\n",
    "        if token not in self.tokens.keys():\n",
    "            return False\n",
    "        result = self.tokens[token]['token'].transferFrom(address, self.address, amount)\n",
    "        if result:\n",
    "            if address not in self.cdp[token]:\n",
    "                self.cdp[token][address] = {'amount':amount, 'debt':Decimal('0')}\n",
    "            else:\n",
    "                self.cdp[token][address]['amount'] += amount\n",
    "        else:\n",
    "            return False\n",
    "      \n",
    "    def withdrawCollateral(self, token, address, amount):\n",
    "        if token not in self.tokens.keys():\n",
    "            return False\n",
    "        # check oracle price\n",
    "        price = self.oracle.currentPrice()\n",
    "        minimumCollateral = self.oracle.currentPrice() * self.collateralizationRatio * \\\n",
    "                            (self.cdp[token][address]['debt'] * self.debtAccumulator - amount)\n",
    "        if self.cdp[token][address]['amount'] < minimumCollateral:\n",
    "            raise Exception(\"withdrawCollateral: Insufficient free capital to withdraw\")\n",
    "        result = self.tokens[token].transferFrom(self.address, address, amount)\n",
    "        if result:\n",
    "            self.cdp[token][address]['amount'] = self.cdp[token][address]['amount'] - amount\n",
    "    \n",
    "    # accrue for both debt and interest\n",
    "    def accrueInterest(self):\n",
    "        now = self.blockchain.now()\n",
    "        if now > self.lastUpdate:\n",
    "            total_time =  now - self.lastUpdate\n",
    "            self.rateAccumulator = math.power(self.rate, total_time) * self.rateAccumulator\n",
    "            self.debtAccumulator = math.power(self.debtRate, total_time) * self.debtAccumulator\n",
    "            self.lastUpdate = now\n",
    "        \n",
    "    # updateRate for both debt and interest\n",
    "    # this contract implicity assumes that this is called every block\n",
    "    def updateRate(self, update):\n",
    "        newRate = math.power(1 + Decimal(update), 1/Decimal(31622400)) - 1\n",
    "        self.rate = self.rate + newRate\n",
    "        self.debtRate = self.rate + newRate\n",
    "        if self.rate < Decimal(1):\n",
    "            self.rate = Decimal(1)\n",
    "        if self.rate > self.interestRateLimit:\n",
    "            self.rate = self.interestRateLimit\n",
    "        \n",
    "    \n",
    "    def getCollateral(self, token, address):\n",
    "        return self.cdp[token][address]['amount'] \n",
    "    \n",
    "    def getDebt(self, token, address):\n",
    "        return self.cdp[token][address]['debt'] \n",
    "    \n",
    "    def debtInUnderlying(self, token, address):\n",
    "        return self.cdp[token][address]['debt'] * self.debtAccumulator\n",
    "    \n",
    "    # borrow against a particular tokens worth of collateral\n",
    "    def borrow(self, token, address, amount):\n",
    "        if token not in self.tokens.keys():\n",
    "            raise Exception(\"Borrow: Token not found\")\n",
    "        if amount < 0:\n",
    "            raise Exception(\"Borrow: Cannot borrow negative amounts\")\n",
    "            self.tokens[token.name()] = { 'token':token, 'oracle':oracle }\n",
    "        price = self.tokens[token]['oracle'].getPriceInToken(self.underlying)\n",
    "        minimumCollateral = ( 1 / price) * self.collateralizationRatio * \\\n",
    "                            (self.cdp[token][address]['debt'] * self.debtAccumulator + amount)\n",
    "        if self.cdp[token][address]['amount'] < minimumCollateral:\n",
    "            raise Exception(\"Borrow: Insufficient collateral Available: {} Minimum Needed: {}\".format(self.cdp[token][address]['amount'], minimumCollateral))\n",
    "        # Add debt\n",
    "        self.cdp[token][address]['debt'] = self.cdp[token][address]['debt'] + Decimal(amount) / self.debtAccumulator\n",
    "        # Add borrow\n",
    "        self.mintInUnderlying(address, amount)\n",
    "        try:\n",
    "            assert(self.balanceOfUnderlying(address) >= amount)\n",
    "        except:     \n",
    "            print(\"amount minted: {} balance: {}\".format(amount, self.balanceOfUnderlying(address)))\n",
    "        \n",
    "    def maximumBorrow(self, token, address):\n",
    "        price = self.tokens[token]['oracle'].getPriceInToken(self.underlying)\n",
    "        maximumBorrow = self.cdp[token][address]['amount'] * price * \\\n",
    "                         (1 / self.collateralizationRatio) \n",
    "        return maximumBorrow\n",
    "    \n",
    "\n",
    "       \n",
    "    def liquidate(self, token, addressToLiquidate, LiquidatorAddress, amount):\n",
    "        price = self.tokens[token]['oracle'].getPriceInToken(self.underlying)\n",
    "        maximumBorrow = self.maximumBorrow(token, addressToLiquidate)\n",
    "        debt = self.debtInUnderlying(token, addressToLiquidate)\n",
    "        if maximumBorrow < debt:\n",
    "            # We need to liquidate\n",
    "            if amount < debt:\n",
    "                raise Exception(\"liquidate: Must liquidate entire CDP at once\")\n",
    "            availableFunds = self.balanceOfUnderlying(LiquidatorAddress)\n",
    "            if availableFunds < amount:\n",
    "                raise Exception(\"liquidate: Insufficient funds to liquidate\")\n",
    "            \n",
    "            collateralToLiquidator = debt*self.bonus/price\n",
    "            if collateralToLiquidator > self.cdp[token][addressToLiquidate]['amount']:\n",
    "                raise Exception(\"liquidate: CDP liquidated while undercollateralized. Owed to Liquidator: {} Available: {}\".format(collateralToLiquidator, self.cdp[token][addressToLiquidate]['amount']))\n",
    "            # Only burn amount of debt--it's possible to specify more than debt and have liquidate succeed\n",
    "            self.burn(LiquidatorAddress, self.getDebt(token, addressToLiquidate))\n",
    "            # Transfer liquidated funds to Liquidator\n",
    "            self.tokens[token]['token'].transferFrom(self.address, LiquidatorAddress, collateralToLiquidator)\n",
    "            # Debit CDP account \n",
    "            self.cdp[token][addressToLiquidate]['amount'] -= collateralToLiquidator\n",
    "            # Wipe Debt\n",
    "            self.cdp[token][addressToLiquidate]['debt'] = 0\n",
    "        else:\n",
    "            raise Exception(\"liquidate: Cannot liquidate a working CDP\")\n",
    "        \n",
    "    # Position in a particular collateral token\n",
    "    def position(self, token, address):\n",
    "        return self.cdp[token][address]\n",
    "    \n",
    "    def repay(self, token, address, amount):\n",
    "        if token not in self.tokens.keys():\n",
    "            return False\n",
    "        if amount < 0:\n",
    "            return False        \n",
    "        if amount < self.debtInUnderlying(token, address):\n",
    "            raise Exception(\"Cannot repay more than available debt\")\n",
    "        # Decrease debt\n",
    "        self.cdp[token][address]['debt'] = self.cdp[token][address]['debt'] - Decimal(amount) / self.debtAccumulator\n",
    "        assert(self.cdp[token][address]['debt'] >= 0)\n",
    "        self.burnInUnderlying(address, amount)\n",
    "        \n",
    "        \n",
    "    def updateRates(self):\n",
    "        imbalance = self.qx.measureImbalance()\n",
    "        if imbalance == 0:\n",
    "            return \n",
    "        if imbalance > 0:\n",
    "            # lower interest rate\n",
    "            self.updateRate(-self.interestUpdateAmount)\n",
    "        elif imbalance < 0:\n",
    "            # raise interest rate\n",
    "            self.updateRate(self.interestUpdateAmount)\n",
    "    \n",
    "        \n",
    "        \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 262,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Basic test of pyToken class\n",
    "\n",
    "chain = blockchain(1,1)\n",
    "BAT = Token(\"BAT\")\n",
    "DAI = Token(\"DAI\")\n",
    "oracleA = Oracle(BAT, DAI)\n",
    "\n",
    "collateral = Token(\"Collateral\")\n",
    "oracleC = Oracle(collateral, BAT)\n",
    "oracleC.setPrice(Decimal(1000000))\n",
    "pyBAT = pyToken(chain, BAT, oracleA)\n",
    "pyBAT.addCollateralType(collateral, oracleC)\n",
    "qx = QueueExchange(\"QX:TokenA\", BAT , pyBAT)\n",
    "pyBAT.setQueueExchange(qx)\n",
    "\n",
    "oracleC.setPrice(Decimal(1000))\n",
    "BAT.mint(\"A\", Decimal('1000'))\n",
    "collateral.mint(\"B\", Decimal('1000'))\n",
    "pyBAT.addCollateral(\"Collateral\", \"B\", Decimal('100'))\n",
    "pyBAT.borrow(\"Collateral\", \"B\", Decimal('10'))\n",
    "pyBAT.repay(\"Collateral\", \"B\", Decimal('10'))\n",
    "pyBAT.borrow(\"Collateral\", \"B\", Decimal('10'))\n",
    "assert(pyBAT.balanceOf(\"B\") == Decimal('10'))\n",
    "qx.depositSynthetic(\"B\", Decimal('10'))\n",
    "#qx.depositUnderlying(\"A\", Decimal('10'))\n",
    "#qx.withdrawSynthetic(\"A\", Decimal('10'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Liquidation Test\n",
    "oracleC.getPriceInToken(collateral)\n",
    "debt = pyBAT.debtInUnderlying(\"Collateral\", \"B\")\n",
    "maxBorrow = pyBAT.maximumBorrow(\"Collateral\", \"B\")\n",
    "pyBAT.borrow(\"Collateral\", \"B\", maxBorrow-debt)\n",
    "# Now make repo undercollateralized\n",
    "oracleC.setPriceInToken(BAT, Decimal(900))\n",
    "pyBAT.mint(\"A\", Decimal('100000'))\n",
    "pyBAT.liquidate(\"Collateral\", \"B\", \"A\", pyBAT.debtInUnderlying(\"Collateral\", \"B\"))\n",
    "assert(pyBAT.debtInUnderlying(\"Collateral\", \"B\") == Decimal('0'))\n",
    "assert(collateral.balanceOf(\"A\") == Decimal('71.89542483660130718954248367'))\n",
    "assert(pyBAT.getCollateral(\"Collateral\", \"B\") + collateral.balanceOf(\"A\") == Decimal('100.0000000000000000000000000'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [],
   "source": [
    "# External market that provides \"infinite\" liquidity\n",
    "class ReferenceExchange:\n",
    "    def __init__(self):\n",
    "        self.tokenPairs = {}\n",
    "        self.address = \"0xReferenceExchange\"\n",
    "    \n",
    "    # Add pair. The price is the number of tokenB per tokenA\n",
    "    def addPair(self, tokenA, tokenB):\n",
    "        firstToken = tokenB.name()\n",
    "        secondToken = tokenA.name()\n",
    "        if tokenA.name() > tokenB.name():\n",
    "            firstToken = tokenA.name()\n",
    "            secondToken = tokenB.name()\n",
    "        \n",
    "        if firstToken not in self.tokenPairs.keys():\n",
    "            self.tokenPairs[firstToken] = {secondToken: {}}\n",
    "        self.tokenPairs[firstToken][secondToken] = {'Base':tokenA, 'Quote':tokenB, 'Price':Decimal('0')}  \n",
    "        \n",
    "        # mint a lot of tokens for both sides\n",
    "        tokenA.mint(self.address, Decimal(1000000000))\n",
    "        tokenB.mint(self.address, Decimal(1000000000))\n",
    "\n",
    "    \n",
    "    def updatePairPrice(self, tokenA, tokenB, price):\n",
    "        firstToken = tokenB.name()\n",
    "        secondToken = tokenA.name()\n",
    "        if tokenA.name() > tokenB.name():\n",
    "            firstToken = tokenA.name()\n",
    "            secondToken = tokenB.name()\n",
    "        self.tokenPairs[firstToken][secondToken]['Price'] = price\n",
    "    \n",
    "    def trade(self, tokenA, tokenB, tokenAAmount, address):\n",
    "        # transfer in tokenA\n",
    "        result = tokenA.transferFrom(address, self.address, tokenAAmount)\n",
    "        if result: \n",
    "            firstToken = tokenB.name()\n",
    "            secondToken = tokenA.name()\n",
    "            if tokenA.name() > tokenB.name():\n",
    "                firstToken = tokenA.name()\n",
    "                secondToken = tokenB.name()\n",
    "            pair = self.tokenPairs[firstToken][secondToken]\n",
    "            multiplier = 0\n",
    "            if pair['Quote'].name() == tokenB.name():\n",
    "                multiplier = pair['Price']\n",
    "            else:\n",
    "                multiplier = 1/pair['Price']\n",
    "            # calculate amount of tokenB to send\n",
    "            tokens_to_send = tokenAAmount * multiplier\n",
    "            # send tokenB to address\n",
    "            transferR = tokenB.transferFrom(self.address, address, tokens_to_send)\n",
    "            return (tokens_to_send, transferR)\n",
    "        else:\n",
    "            raise Exception(\"Trade: Token transfer failed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class Interface:\n",
    "    \n",
    "    def __init__(self, _chain : blockchain, _uTokenA : Token, _uTokenB : Token, oracle):\n",
    "        self.A = _uTokenA\n",
    "        self.B = _uTokenB\n",
    "        self.chain = _chain\n",
    "        self.oracle = oracle\n",
    "        self.pyA = pyToken(_chain, self.A, oracle)\n",
    "        self.pyB = pyToken(_chain, self.B, oracle)\n",
    "        self.pyA.setPair(self.pyB)\n",
    "        self.pyB.setPair(self.pyA)\n",
    "        self.qxA = QueueExchange(\"QX:\" + self.A.name(), self.A , self.pyA)\n",
    "        self.qxB = QueueExchange(\"QX:\" + self.B.name(), self.B , self.pyB)\n",
    "        self.pyA.setQueueExchange(self.qxB)\n",
    "        self.pyB.setQueueExchange(self.qxA)\n",
    "        # Add \"ETH\" as acceptable collateral\n",
    "        self.eth = Token(\"ETH\")\n",
    "        self.ethAOracle = Oracle(self.eth, self.A)\n",
    "        self.ethBOracle = Oracle(self.eth, self.B)\n",
    "        self.ethAOracle.setPrice(Decimal('100'))\n",
    "        self.ethBOracle.setPrice(Decimal(100/oracle.currentPrice()))\n",
    "        self.pyA.addCollateralType(self.eth, self.ethAOracle)\n",
    "        self.pyB.addCollateralType(self.eth, self.ethBOracle)\n",
    "        self.ref = ReferenceExchange()\n",
    "        self.ref.addPair(self.eth, self.A)\n",
    "        self.ref.updatePairPrice(self.eth, self.A, self.ethAOracle.currentPrice())\n",
    "        self.ref.addPair(self.eth, self.B)\n",
    "        self.ref.updatePairPrice(self.eth, self.B, self.ethBOracle.currentPrice())\n",
    "        \n",
    "    def updateInterestRates(self):\n",
    "        self.pyA.updateRates()\n",
    "        self.pyB.updateRates()\n",
    "        self.pyA.accrueInterest()\n",
    "        self.pyB.accrueInterest()\n",
    "    \n",
    "    def eachBlock(self):\n",
    "        self.chain.incrementBlock()\n",
    "        self.updateInterestRates()\n",
    "        \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy \n",
    "import random\n",
    "\n",
    "    \n",
    "class Agent:\n",
    "    def __init__(self, _interface):\n",
    "        self.interface = _interface\n",
    "        self.address = numpy.random.randint(1,1000)\n",
    "        \n",
    "    def setup(self):\n",
    "        pass\n",
    "    \n",
    "    def performActions(self):\n",
    "        pass\n",
    "    \n",
    "    def shutdown(self):\n",
    "        pass\n",
    "    \n",
    "    \n",
    "# Yield agents sell their underlying for pyTokens and hodl them\n",
    "class YieldAgent(Agent):\n",
    "    def __init__(self, _interface):\n",
    "        super().__init__(_interface)\n",
    "        self.address = \"0xYA_HodlPY\" + str(self.address)\n",
    "        \n",
    "    def setup(self):   \n",
    "        #self.initialA = min(Decimal(round(numpy.random.lognormal(14, 1))), Decimal(1000000000))\n",
    "        #self.initialB = min(Decimal(round(numpy.random.lognormal(14, 1))), Decimal(1000000000))\n",
    "        self.initialA =  Decimal(1000000000)\n",
    "        self.initialB =  Decimal(1000000000)\n",
    "        self.interface.A.mint(self.address, Decimal(self.initialA))\n",
    "        self.interface.B.mint(self.address, Decimal(self.initialB))\n",
    "        self.initial_exchange_rate = self.interface.oracle.currentPrice()\n",
    "    \n",
    "    def performActions(self):\n",
    "        if random.choice([\"HODL\",\"NOT\"]) == \"HODL\":\n",
    "            self.HODL()\n",
    "        else:\n",
    "            self.unHODL()\n",
    "        \n",
    "    def HODL(self):\n",
    "        amount = min(self.interface.qxA.sTokenBalanceUnderlying, \n",
    "                     self.interface.A.balanceOf(self.address))\n",
    "        if amount > 0:\n",
    "            self.interface.qxA.depositUnderlying(self.address, amount)\n",
    "            toWithdraw = min(self.interface.qxA.maxSynthetic(), \n",
    "                             self.interface.qxA.balanceOfUnderlying(self.address),\n",
    "                             self.interface.qxA.sTokenBalanceUnderlying)\n",
    "            if toWithdraw > 0:\n",
    "                self.interface.qxA.withdrawSynthetic(self.address, toWithdraw)\n",
    "        \n",
    "        amount = min(self.interface.qxB.sTokenBalanceUnderlying, \n",
    "                     self.interface.B.balanceOf(self.address))\n",
    "        #print(self.interface.qxB.sTokenBalanceUnderlying)\n",
    "        if amount > 0:\n",
    "            self.interface.qxB.depositUnderlying(self.address, amount)\n",
    "            toWithdraw = min(self.interface.qxB.maxSynthetic(), \n",
    "                             self.interface.qxB.balanceOfUnderlying(self.address),\n",
    "                             self.interface.qxB.sTokenBalanceUnderlying)\n",
    "            if toWithdraw > 0:\n",
    "                self.interface.qxB.withdrawSynthetic(self.address, toWithdraw)\n",
    "    \n",
    "    \n",
    "    def unHODL(self):\n",
    "        amount = min(self.interface.qxA.uTokenBalance, \n",
    "                     self.interface.pyA.balanceOf(self.address))\n",
    "        if amount > 0:\n",
    "            self.interface.qxA.depositSynthetic(self.address, amount)\n",
    "            toWithdraw = min(self.interface.qxA.maxUnderlying(), \n",
    "                             self.interface.qxA.balanceOfUnderlying(self.address),\n",
    "                             self.interface.qxA.uTokenBalance)\n",
    "            if toWithdraw > 0:\n",
    "                self.interface.qxA.withdrawUnderlying(self.address, toWithdraw)\n",
    "        \n",
    "        amount = min(self.interface.qxB.uTokenBalance, \n",
    "                     self.interface.pyB.balanceOf(self.address))\n",
    "        if amount > 0:\n",
    "            self.interface.qxB.depositSynthetic(self.address, amount)\n",
    "            toWithdraw = min(self.interface.qxB.maxUnderlying(), \n",
    "                             self.interface.qxB.balanceOfUnderlying(self.address),\n",
    "                             self.interface.qxB.uTokenBalance)\n",
    "            if toWithdraw > 0:\n",
    "                self.interface.qxB.withdrawUnderlying(self.address, toWithdraw)\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    def shutdown(self):\n",
    "        pass\n",
    "    \n",
    "    \n",
    "    \n",
    "# Underlying Liquidity agents sell their underlying for inDEX LP tokens and hodl them\n",
    "class ULiquidityAgent(Agent):\n",
    "    def __init__(self, _interface):\n",
    "        super().__init__(_interface)\n",
    "        self.address = \"0xUL_HodlLP\" + str(self.address)\n",
    "        \n",
    "    def setup(self):   \n",
    "        self.initialA = min(Decimal(round(numpy.random.lognormal(14, 1))), Decimal(1000000000))\n",
    "        self.initialB = min(Decimal(round(numpy.random.lognormal(14, 1))), Decimal(1000000000))\n",
    "        self.interface.A.mint(self.address, Decimal(self.initialA))\n",
    "        self.interface.B.mint(self.address, Decimal(self.initialB))\n",
    "        self.initial_exchange_rate = self.interface.oracle.currentPrice()\n",
    "    \n",
    "    def performActions(self):\n",
    "        amount = self.interface.A.balanceOf(self.address)\n",
    "        if amount > 0:\n",
    "            self.interface.qxA.depositUnderlying(self.address, amount)\n",
    "        \n",
    "        amount = self.interface.B.balanceOf(self.address)\n",
    "        if amount > 0:\n",
    "            self.interface.qxB.depositUnderlying(self.address, amount)\n",
    "    \n",
    "    \n",
    "    def shutdown(self):\n",
    "        pass\n",
    "\n",
    "    \n",
    "# Underlying Liquidity agents sell their underlying for inDEX LP tokens and hodl them\n",
    "class LiquidiationAgent(Agent):\n",
    "    def __init__(self, _interface):\n",
    "        super().__init__(_interface)\n",
    "        self.address = \"0xLA_Liquid8\" + str(self.address)\n",
    "        \n",
    "    def setup(self):   \n",
    "        self.interface.pyA.mint(self.address, Decimal(1000000000000))\n",
    "        self.interface.pyB.mint(self.address, Decimal(1000000000000))\n",
    "        self.interface.A.mint(self.address, Decimal(1000000000000))\n",
    "        self.interface.B.mint(self.address, Decimal(1000000000000))\n",
    "    \n",
    "    def performActions(self):\n",
    "        for address in self.interface.pyA.cdp[\"ETH\"]:\n",
    "            maximumBorrow = self.interface.pyA.maximumBorrow(\"ETH\", address)\n",
    "            debt = self.interface.pyA.debtInUnderlying(\"ETH\", address)\n",
    "            if debt > maximumBorrow:\n",
    "                print(\"Liquidating {} who has debt {} and assets {}\".format(address, debt, self.interface.pyA.getCollateral(\"ETH\", address)))\n",
    "                # liquidate\n",
    "                self.interface.pyA.liquidate(\"ETH\", address, self.address, debt)\n",
    "                # try to buy back spent pyTokens\n",
    "                available = min(self.interface.qxA.sTokenBalanceUnderlying, debt)\n",
    "                if available > 0:\n",
    "                    self.interface.qxA.depositUnderlying(self.address, available)\n",
    "                    toWithdraw = min(self.interface.qxA.balanceOfUnderlying(self.address), self.interface.qxA.maxSynthetic())\n",
    "                    if toWithdraw > 0:\n",
    "                        self.interface.qxA.withdrawSynthetic(self.address, toWithdraw)\n",
    "\n",
    "    \n",
    "    def shutdown(self):\n",
    "        pass\n",
    "    \n",
    "    \n",
    "# Synthetic Liquidity agents borrow synthetic and deposit in the inDEX (QX exchange)\n",
    "class SLiquidityAgent(Agent):\n",
    "    def __init__(self, _interface):\n",
    "        super().__init__(_interface)\n",
    "        self.address = \"0xSL_HodlLP\" + str(self.address)\n",
    "        \n",
    "    def setup(self):\n",
    "        self.initialETH = min(Decimal(round(numpy.random.lognormal(14, 1))), Decimal(1000000000))\n",
    "        self.interface.eth.mint(self.address, Decimal(self.initialETH ))\n",
    "        self.interface.pyA.addCollateral(\"ETH\", self.address, self.initialETH/2 )\n",
    "        self.interface.pyB.addCollateral(\"ETH\", self.address, self.initialETH/2 )\n",
    "    \n",
    "    def ETHForA(self):\n",
    "        if self.interface.pyA.yearlyRate() > 0.2:\n",
    "            #Rates are kind of silly, let's stop\n",
    "            return\n",
    "        pos = self.interface.pyA.position(\"ETH\", self.address)\n",
    "        debt = self.interface.pyA.debtInUnderlying(\"ETH\", self.address)\n",
    "        price = self.interface.ethAOracle.getPriceInToken(self.interface.A)\n",
    "        maxborrowable = (pos['amount'] * price ) / (self.interface.pyA.collateralizationRatio )\n",
    "        # Only borrow half of what's available\n",
    "        maxavailable =  (maxborrowable - debt)/2\n",
    "        #print(\"MaxAvailable: {} Actual Max: {}\".format(maxavailable, \n",
    "        #                                               self.interface.pyA.maximumBorrow(self.interface.eth.name(), self.address)))\n",
    "        if maxavailable > 0.01:\n",
    "            self.interface.pyA.borrow(\"ETH\", self.address, maxavailable)\n",
    "            assert(self.interface.pyA.balanceOfUnderlying(self.address) == maxavailable)\n",
    "            self.interface.qxA.depositSynthetic(self.address, maxavailable)\n",
    "\n",
    "            \n",
    "    def ETHForB(self):\n",
    "        if self.interface.pyB.yearlyRate() > 0.2:\n",
    "            #Rates are kind of silly, let's stop\n",
    "            return\n",
    "        pos = self.interface.pyB.position(\"ETH\", self.address)\n",
    "        debt = self.interface.pyB.debtInUnderlying(\"ETH\", self.address)\n",
    "        price = self.interface.ethBOracle.getPriceInToken(self.interface.B)\n",
    "        maxborrowable = (pos['amount'] * price ) / (self.interface.pyB.collateralizationRatio )\n",
    "        # Only borrow half of what's available\n",
    "        maxavailable =  (maxborrowable - debt)/2\n",
    "        #print(\"MaxAvailable: {} Actual Max: {}\".format(maxavailable, \n",
    "        #                                               self.interface.pyB.maximumBorrow(self.interface.eth.name(), self.address)))\n",
    "        if maxavailable > 0.01:\n",
    "            result = self.interface.pyB.borrow(\"ETH\", self.address, maxavailable)\n",
    "            assert(self.interface.pyB.balanceOfUnderlying(self.address) == maxavailable)\n",
    "            self.interface.qxB.depositSynthetic(self.address, maxavailable)\n",
    "    \n",
    "    def performActions(self):\n",
    "        start = random.choice([\"A\",\"B\",1,2,3,4])\n",
    "        if start == \"A\":\n",
    "            self.ETHForA()\n",
    "            self.ETHForB()\n",
    "        elif start == \"B\":\n",
    "            self.ETHForB()\n",
    "            self.ETHForA()\n",
    "        \n",
    "    \n",
    "    def shutdown(self):\n",
    "        pass\n",
    "    \n",
    "# Borrow agents lever up on ETH collateral by selling pyTokens\n",
    "class BorrowAgent(Agent):\n",
    "    def __init__(self, _interface):\n",
    "        super().__init__(_interface)\n",
    "        self.address = \"0xBA_longETH\" + str(self.address)\n",
    "        \n",
    "    def setup(self):\n",
    "        self.initialETH = min(Decimal(round(numpy.random.lognormal(14, 1))), Decimal(1000000000))\n",
    "        self.interface.eth.mint(self.address, Decimal(self.initialETH ))\n",
    "        ethReserve = self.initialETH * Decimal('0.1')\n",
    "        each = (self.initialETH - ethReserve)/2\n",
    "        self.interface.pyA.addCollateral(\"ETH\", self.address, each )\n",
    "        self.interface.pyB.addCollateral(\"ETH\", self.address, each )\n",
    "    \n",
    "    def ETHForA(self):\n",
    "        pos = self.interface.pyA.position(\"ETH\", self.address)\n",
    "        debt = self.interface.pyA.debtInUnderlying(\"ETH\", self.address)\n",
    "        price = self.interface.ethAOracle.getPriceInToken(self.interface.A)\n",
    "        maxborrowable = (pos['amount'] * price) / (self.interface.pyA.collateralizationRatio )\n",
    "        maxavailable = min(self.interface.qxA.uTokenBalance, (maxborrowable - debt)/2)\n",
    "        #print(\"MaxAvailable: {} Actual Max: {}\".format(maxavailable, \n",
    "        #                                               self.interface.pyA.maximumBorrow(self.interface.eth.name(), self.address)))\n",
    "        # If we get too small, we start having numerical issues\n",
    "        if maxavailable > 1:\n",
    "            self.interface.pyA.borrow(\"ETH\", self.address, maxavailable)\n",
    "            assertNearly(self.interface.pyA.balanceOfUnderlying(self.address),maxavailable,\"ok\", 10)\n",
    "            #assert(self.interface.pyA.balanceOfUnderlying(self.address) == maxavailable)\n",
    "            self.interface.qxA.depositSynthetic(self.address, maxavailable)\n",
    "            try:\n",
    "                assert(self.interface.qxA.balanceOfUnderlying(self.address) >= maxavailable)\n",
    "            except:\n",
    "                print(\"After syn deposit, syn balance of pyA: {} attempted: {}\".format(self.interface.qxA.balanceOfUnderlying(self.address), maxavailable))\n",
    "            toWithdraw = min(self.interface.qxB.maxUnderlying(), \n",
    "                             self.interface.qxB.balanceOfUnderlying(self.address),\n",
    "                             self.interface.qxB.uTokenBalance)\n",
    "            if toWithdraw > 0:\n",
    "                self.interface.qxA.withdrawUnderlying(self.address, toWithdraw)\n",
    "            #Trade underlying for ETH and deposit\n",
    "            currentbalance = self.interface.A.balanceOf(self.address)\n",
    "            (sentTokens, result) = self.interface.ref.trade(self.interface.A, self.interface.eth, currentbalance, self.address)\n",
    "            self.interface.pyA.addCollateral(\"ETH\", self.address, sentTokens)\n",
    "            #print(\"Added {} ETH to pyA\".format(sentTokens))\n",
    "            \n",
    "    def UnwindA(self):\n",
    "        debt = self.interface.pyA.debtInUnderlying(\"ETH\", self.address)\n",
    "        maxavailable = min(self.interface.qxA.sTokenBalanceUnderlying, debt)\n",
    "        self.interface.qxA.depositUnderlying(self.address, maxavailable)\n",
    "        self.interface.qxA.withdrawSynthetic(self.address, maxavailable)\n",
    "        self.interface.pyA.repay(\"ETH\", self.address, maxavailable)\n",
    "    \n",
    "    \n",
    "    def ETHForB(self):\n",
    "        pos = self.interface.pyB.position(\"ETH\", self.address)\n",
    "        debt = self.interface.pyB.debtInUnderlying(\"ETH\", self.address)\n",
    "        price = self.interface.ethBOracle.getPriceInToken(self.interface.B)\n",
    "        maxborrowable = (pos['amount'] * price ) / (self.interface.pyB.collateralizationRatio )\n",
    "        maxavailable = min(self.interface.qxB.uTokenBalance, (maxborrowable - debt)/2)\n",
    "        #print(\"MaxAvailable: {} Actual Max: {}\".format(maxavailable, \n",
    "        #                                               self.interface.pyB.maximumBorrow(self.interface.eth.name(), self.address)))\n",
    "        # If we get too small, we start having numerical issues\n",
    "        if maxavailable > 1:\n",
    "            self.interface.pyB.borrow(\"ETH\", self.address, maxavailable)\n",
    "            assertNearly(self.interface.pyB.balanceOfUnderlying(self.address),maxavailable,\"ok\", 10)\n",
    "            #assert(self.interface.pyB.balanceOfUnderlying(self.address) == maxavailable)\n",
    "            self.interface.qxB.depositSynthetic(self.address, maxavailable)\n",
    "            try:\n",
    "                assert(self.interface.qxB.balanceOfUnderlying(self.address) >= maxavailable)\n",
    "            except:\n",
    "                print(\"After syn deposit, syn balance of pyB: {} attempted: {}\".format(self.interface.qxB.balanceOfUnderlying(self.address), maxavailable))\n",
    "            toWithdraw = min(self.interface.qxB.maxUnderlying(), \n",
    "                             self.interface.qxB.balanceOfUnderlying(self.address),\n",
    "                             self.interface.qxB.uTokenBalance)\n",
    "            \n",
    "            if toWithdraw > 0:\n",
    "                self.interface.qxB.withdrawUnderlying(self.address, toWithdraw)\n",
    "            #Trade underlying for ETH and deposit\n",
    "            currentbalance = self.interface.B.balanceOf(self.address)\n",
    "            (sentTokens, result) = self.interface.ref.trade(self.interface.B, self.interface.eth, currentbalance, self.address)\n",
    "            self.interface.pyB.addCollateral(\"ETH\", self.address, sentTokens)\n",
    "            #print(\"Added {} ETH to pyB\".format(sentTokens))\n",
    "    \n",
    "    def performActions(self):\n",
    "        start = random.choice([\"A\",\"B\"])\n",
    "        if start == \"A\":\n",
    "            self.ETHForA()\n",
    "            self.ETHForB()\n",
    "        else:\n",
    "            self.ETHForB()\n",
    "            self.ETHForA()\n",
    "        \n",
    "    \n",
    "    def shutdown(self):\n",
    "        pass\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple Set of Agents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {},
   "outputs": [
    {
     "ename": "Exception",
     "evalue": "collectSyntheticInterest: sToken balance mismatch sTokenBalanceUnderlying:6344.934087826712258466342160 sTokenBalance:6344.934026437693307863854180 conversionRate:1.002223889551295285614314827",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-256-f1313c7e1936>\u001b[0m in \u001b[0;36mcollectSyntheticInterest\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     55\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 56\u001b[0;31m             \u001b[0;32massert\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mround\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msTokenBalanceUnderlying\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mround\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msTokenBalance\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msToken\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrateAccumulator\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     57\u001b[0m         \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAssertionError\u001b[0m: ",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mException\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-267-2b515ebb9998>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     37\u001b[0m     \u001b[0mpyAinterest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minterface\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpyA\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0myearlyRate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     38\u001b[0m     \u001b[0mpyBinterest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minterface\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpyA\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0myearlyRate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 39\u001b[0;31m     \u001b[0mqxA\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minterface\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mqxA\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmeasureImbalance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     40\u001b[0m     \u001b[0mqxB\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minterface\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mqxB\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmeasureImbalance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     41\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-256-f1313c7e1936>\u001b[0m in \u001b[0;36mmeasureImbalance\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    154\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    155\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mmeasureImbalance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 156\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcollectSyntheticInterest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    157\u001b[0m         \u001b[0;31m# If balance difference is under 5% of the total, treat as if there is no imbalance\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    158\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtotalSupply\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-256-f1313c7e1936>\u001b[0m in \u001b[0;36mcollectSyntheticInterest\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     56\u001b[0m             \u001b[0;32massert\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mround\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msTokenBalanceUnderlying\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mround\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msTokenBalance\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msToken\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrateAccumulator\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     57\u001b[0m         \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 58\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"collectSyntheticInterest: sToken balance mismatch sTokenBalanceUnderlying:{} sTokenBalance:{} conversionRate:{}\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msTokenBalanceUnderlying\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msTokenBalance\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconversionRate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     59\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     60\u001b[0m         \u001b[0;31m# fail if our accounting of balance does not match true balance\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mException\u001b[0m: collectSyntheticInterest: sToken balance mismatch sTokenBalanceUnderlying:6344.934087826712258466342160 sTokenBalance:6344.934026437693307863854180 conversionRate:1.002223889551295285614314827"
     ]
    }
   ],
   "source": [
    "import numpy\n",
    "\n",
    "chain = blockchain(1,1)\n",
    "oracle.setPrice(Decimal('2'))\n",
    "tokenA = Token(\"TokenA\")\n",
    "tokenB = Token(\"TokenB\")\n",
    "oracle = Oracle(tokenA, tokenB)\n",
    "oracle.setPrice(Decimal('1'))\n",
    "interface = Interface(chain, tokenA, tokenB, oracle)\n",
    "\n",
    "pyAinterest = []\n",
    "pyBinterest = []\n",
    "qxA = []\n",
    "qxB = []\n",
    "\n",
    "#Create users\n",
    "\n",
    "user1 = YieldAgent(interface)\n",
    "user2 = BorrowAgent(interface)\n",
    "user3 = ULiquidityAgent(interface)\n",
    "user4 = SLiquidityAgent(interface)\n",
    "user5 = LiquidiationAgent(interface)\n",
    "users = [user1, user2, user3, user4, user5]\n",
    "\n",
    "# Setup\n",
    "for user in users:\n",
    "    user.setup()\n",
    "\n",
    "# Run\n",
    "for block in range(100000):\n",
    "    # perform interest rate update at beginning of block\n",
    "    interface.eachBlock()\n",
    "    \n",
    "    for user in users:\n",
    "        user.performActions()\n",
    "    \n",
    "    pyAinterest.append(float(interface.pyA.yearlyRate()))\n",
    "    pyBinterest.append(float(interface.pyA.yearlyRate()))\n",
    "    qxA.append(int(interface.qxA.measureImbalance()))\n",
    "    qxB.append(int(interface.qxB.measureImbalance()))\n",
    "    \n",
    "# Shutdown\n",
    "for user in users:\n",
    "    user.shutdown()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>TokenA</th>\n",
       "      <th>TokenB</th>\n",
       "      <th>ETH</th>\n",
       "      <th>pyTokenA</th>\n",
       "      <th>pyTokenB</th>\n",
       "      <th>QX:TokenA</th>\n",
       "      <th>QX:TokenB</th>\n",
       "      <th>pyA_ETHc</th>\n",
       "      <th>pyB_ETHc</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0xReferenceExchange</td>\n",
       "      <td>1000000000</td>\n",
       "      <td>1056798929</td>\n",
       "      <td>1999432011</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0xYA_HodlPY233</td>\n",
       "      <td>910033713</td>\n",
       "      <td>876622261</td>\n",
       "      <td>0</td>\n",
       "      <td>89966287</td>\n",
       "      <td>123377739</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0xUL_HodlLP6</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1790795</td>\n",
       "      <td>508759</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0xLA_Liquid8102</td>\n",
       "      <td>1000000000000</td>\n",
       "      <td>1000000000000</td>\n",
       "      <td>0</td>\n",
       "      <td>1000000000000</td>\n",
       "      <td>1000000000000</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0xQX:TokenA</td>\n",
       "      <td>91757082</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0xBA_longETH37</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>88459</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>23415891</td>\n",
       "      <td>0</td>\n",
       "      <td>398066</td>\n",
       "      <td>966056</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0xQX:TokenB</td>\n",
       "      <td>0</td>\n",
       "      <td>67087569</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0xpyTokenA</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1529412</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0xpyTokenB</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2097402</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0xSL_HodlLP646</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>66550396</td>\n",
       "      <td>66108599</td>\n",
       "      <td>1131346</td>\n",
       "      <td>1131346</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                            TokenA         TokenB         ETH       pyTokenA  \\\n",
       "0xReferenceExchange     1000000000     1056798929  1999432011              0   \n",
       "0xYA_HodlPY233           910033713      876622261           0       89966287   \n",
       "0xUL_HodlLP6                     0              0           0              0   \n",
       "0xLA_Liquid8102      1000000000000  1000000000000           0  1000000000000   \n",
       "0xQX:TokenA               91757082              0           0              0   \n",
       "0xBA_longETH37                   0              0       88459              0   \n",
       "0xQX:TokenB                      0       67087569           0              0   \n",
       "0xpyTokenA                       0              0     1529412              0   \n",
       "0xpyTokenB                       0              0     2097402              0   \n",
       "0xSL_HodlLP646                   0              0           0              0   \n",
       "\n",
       "                          pyTokenB QX:TokenA QX:TokenB pyA_ETHc pyB_ETHc  \n",
       "0xReferenceExchange              0         0         0        0        0  \n",
       "0xYA_HodlPY233           123377739         0         0        0        0  \n",
       "0xUL_HodlLP6                     0   1790795    508759        0        0  \n",
       "0xLA_Liquid8102      1000000000000         0         0        0        0  \n",
       "0xQX:TokenA                      0         0         0        0        0  \n",
       "0xBA_longETH37                   0  23415891         0   398066   966056  \n",
       "0xQX:TokenB                      0         0         0        0        0  \n",
       "0xpyTokenA                       0         0         0        0        0  \n",
       "0xpyTokenB                       0         0         0        0        0  \n",
       "0xSL_HodlLP646                   0  66550396  66108599  1131346  1131346  "
      ]
     },
     "execution_count": 203,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Display final outcomes\n",
    "\n",
    "import pandas\n",
    "locations = [interface.A, interface.B, interface.eth, interface.pyA, interface.pyB, interface.qxA, interface.qxB]\n",
    "\n",
    "table = {}\n",
    "for loc in locations:\n",
    "    table[loc.name()] = {}\n",
    "    for item in loc.balances:\n",
    "        table[loc.name()][item] = round(loc.balances[item], 0)\n",
    "\n",
    "table['pyA_ETHc'] = {}\n",
    "for item in interface.pyA.cdp['ETH'].keys():\n",
    "    table['pyA_ETHc'][item] = round(interface.pyA.cdp['ETH'][item]['amount'], 0)\n",
    "    \n",
    "table['pyB_ETHc'] = {}\n",
    "for item in interface.pyB.cdp['ETH'].keys():\n",
    "    table['pyB_ETHc'][item] = round(interface.pyB.cdp['ETH'][item]['amount'], 0)\n",
    "    \n",
    "pandas.DataFrame(table).fillna(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1243c7710>"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib\n",
    "pandas.Series(pyAinterest).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1275cea50>"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pandas.Series(qxA).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1790795,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 17046386,\n",
       " 21126425,\n",
       " 23166445,\n",
       " 24186455,\n",
       " 24696460,\n",
       " 24951463,\n",
       " 25078964,\n",
       " 25142714,\n",
       " 0,\n",
       " 41827969,\n",
       " 75110820,\n",
       " 75114804,\n",
       " 75116796,\n",
       " 75117792,\n",
       " 75118290,\n",
       " 75118539,\n",
       " 75118664,\n",
       " 66800006,\n",
       " 79278118,\n",
       " 85517174,\n",
       " 89676542,\n",
       " 89676545,\n",
       " 89676548,\n",
       " 89676548,\n",
       " 88636708,\n",
       " 90716388,\n",
       " 90716388,\n",
       " 90196468,\n",
       " 90976348,\n",
       " 91366288,\n",
       " 91626248,\n",
       " 91561258,\n",
       " 91691238,\n",
       " 91691238,\n",
       " 91691238,\n",
       " 91658743,\n",
       " 91723733,\n",
       " 91707486,\n",
       " 91739981,\n",
       " 91731857,\n",
       " 91744043,\n",
       " 91752166,\n",
       " 91752166,\n",
       " 91752166,\n",
       " 91752166,\n",
       " 91752166,\n",
       " 91752166,\n",
       " 91752166,\n",
       " 91750135,\n",
       " 91754197,\n",
       " 91754197,\n",
       " 91754197,\n",
       " 91754197,\n",
       " 91754197,\n",
       " 91753182,\n",
       " 91754705,\n",
       " 91755467,\n",
       " 91755974,\n",
       " 91755848,\n",
       " 91756101,\n",
       " 91756101,\n",
       " 91756038,\n",
       " 91756165,\n",
       " 91756165,\n",
       " 91756165,\n",
       " 91756133,\n",
       " 91756181,\n",
       " 91756213,\n",
       " 91756213,\n",
       " 91756205,\n",
       " 91756220,\n",
       " 91756220,\n",
       " 91756216,\n",
       " 91756224,\n",
       " 91756224,\n",
       " 91756224,\n",
       " 91756222,\n",
       " 91756226,\n",
       " 91756225,\n",
       " 91756227,\n",
       " 91756227,\n",
       " 91756227,\n",
       " 91756227,\n",
       " 91756227,\n",
       " 91756227,\n",
       " 91756228,\n",
       " 91756228,\n",
       " 91756228,\n",
       " 91756228,\n",
       " 91756228,\n",
       " 91756228,\n",
       " 91756228,\n",
       " 91756228,\n",
       " 91756228,\n",
       " 91756228,\n",
       " 91756228,\n",
       " 91756228,\n",
       " 91756228,\n",
       " 91756228,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756228,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756229,\n",
       " 91756230,\n",
       " 91756229,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756230,\n",
       " 91756229,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756231,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756232,\n",
       " 91756233,\n",
       " 91756232,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756233,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756234,\n",
       " 91756233,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756235,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " 91756236,\n",
       " ...]"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qxA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('1.666666666666666666666666667')"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Decimal(10 - Decimal(5)) / Decimal(5 - 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}