PyTokens ( income distributed as yield).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from decimal import Decimal\n",
    "import time \n",
    "import decimal\n",
    "math = decimal.Context()\n",
    "import numpy \n",
    "import random\n",
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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. Requested: {} Available: {}\".format(amount, self.balances[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": 3,
   "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": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "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 = math.power(1 + Decimal(rate), 1/Decimal(31622400))  \n",
    "        self.interestRateLimit = math.power(1 + Decimal(2), 1/Decimal(31622400)) \n",
    "    \n",
    "    def balanceOfUnderlying(self, address):\n",
    "        return self.balanceOf(address) * self.rateAccumulator\n",
    "    \n",
    "    def transferUnderlying(self, sender, recipient, amount):\n",
    "        value = amount / self.rateAccumulator\n",
    "        return self.transferFrom(sender, recipient, value)\n",
    "    \n",
    "    def totalSupplyUnderlying(self):\n",
    "        return self.totalSupply * self.rateAccumulator\n",
    "        \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.lastUpdate = now\n",
    "    \n",
    "    def updateRate(self, update):\n",
    "        print(\"Using old updateRate for some reason!\")\n",
    "        newRate = 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 math.power(self.rate, Decimal(31622400)) - 1\n",
    "    \n",
    "    def mintInUnderlying(self, address, amount):\n",
    "        return self.mint(address, amount/self.rateAccumulator)\n",
    "        \n",
    "    def burnInUnderlying(self, address, amount):\n",
    "        return self.burn(address, amount/self.rateAccumulator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using old updateRate for some reason!\n",
      "Using old updateRate for some reason!\n",
      "Using old updateRate for some reason!\n",
      "Using old updateRate for some reason!\n",
      "Using old updateRate for some reason!\n"
     ]
    }
   ],
   "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": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# class QX:\n",
    "#  mint(address, amount):\n",
    "#  redeem(address, amount):\n",
    "#   measureRatio(self)\n",
    "#\n",
    "class QX:\n",
    "    def __init__(self, _uToken : Token , _sToken : Token):\n",
    "        self.uToken = _uToken\n",
    "        self.pyToken = _sToken\n",
    "        self.underlying = Decimal('0')\n",
    "        self.synthetic  = Decimal('0')   # denominated in pyTokens\n",
    "        self.address = '0xQX_' + _uToken.name()\n",
    "        self.book = dict()\n",
    "\n",
    "    def mint(self, address, amount):\n",
    "        if amount < 0:\n",
    "            raise Exception(\"mint: Cannot sell a negative amount. Amount: {}\".format(amount))\n",
    "        result = self.uToken.transferFrom(address, self.address, amount)\n",
    "        if result:\n",
    "            self.underlying += amount\n",
    "            result = self.pyToken.mintInUnderlying( self.address, amount)\n",
    "            if not result:\n",
    "                raise Exception(\"mint: Minting pyTokens failed. Amount: {}\".format(amount))\n",
    "            result = self.pyToken.transferUnderlying(self.address, address, amount)\n",
    "            if not result:\n",
    "                raise Exception(\"mint: Token transfer out failed. Amount: {}\".format(amount))\n",
    "        else:\n",
    "            raise Exception(\"mint: Token transfer in failed. Amount: {}\".format(amount))\n",
    "    \n",
    "    def redeem(self, address, amount):\n",
    "        if amount < 0:\n",
    "            raise Exception(\"redeem: Cannot redeem a negative amount. Amount: {}\".format(amount))\n",
    "        if self.underlying < amount:\n",
    "            raise Exception(\"redeem: Cannot withdraw more than available in reserves\")\n",
    "        result = self.pyToken.burnInUnderlying(address, amount)\n",
    "        if result:\n",
    "            outResult = self.uToken.transferFrom(self.address, address, amount)\n",
    "            if not outResult:\n",
    "                raise Exception(\"redeem: Token transfer out failed\")\n",
    "            self.underlying -= amount\n",
    "        else:\n",
    "            raise Exception(\"redeem: Token transfer in failed. Amount: {}\".format(amount))\n",
    "    \n",
    "    \n",
    "    def measureRatio(self):\n",
    "        try:\n",
    "            if self.underlying <= 0:\n",
    "                return Decimal('0')\n",
    "            return Decimal(self.underlying) / Decimal(self.pyToken.getTotalDebt() + self.underlying)\n",
    "        except Exception as e:\n",
    "            print(\"underlying: {} TotalDebt:{}\".format(self.underlying, self.pyToken.getTotalDebt()))\n",
    "            raise e\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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": 9,
   "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')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Issues:\n",
    "# 1. it is possible to pay out more pyTokens that is offset by debt\n",
    "\n",
    "\n",
    "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 = Decimal('1.0')\n",
    "        # totalDebt is normalized by the debtAccumulator\n",
    "        self.totalDebt = Decimal('0.0')\n",
    "        # bonus factor when liquidating\n",
    "        self.bonus = Decimal('1.1')\n",
    "        self.reservesTarget = Decimal('0.3')\n",
    "        self.adjustmentFreeWindow = Decimal('0.1')\n",
    "        # minimumSpread may be deprecated\n",
    "        self.minimumSpread = Decimal('0.1')\n",
    "        self.borrowFee = Decimal('0.1')\n",
    "        self.totalFeeIncome = Decimal('0.0')\n",
    "        self.impliedRate = Decimal('1.0')\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",
    "            accumulatedDebtInterestMultiplier = math.power(self.debtRate, total_time)\n",
    "            self.debtAccumulator = accumulatedDebtInterestMultiplier * self.debtAccumulator\n",
    "            # pay interest out to hodlers\n",
    "            newDebt = (accumulatedDebtInterestMultiplier - Decimal('1')) * (self.totalDebt * self.debtAccumulator)\n",
    "            # self.rateAccumulator = math.power(self.rate, total_time) * self.rateAccumulator\n",
    "            feeIncome = newDebt * self.borrowFee\n",
    "            self.totalFeeIncome += feeIncome\n",
    "            totalPyTokens = self.totalSupply * self.rateAccumulator\n",
    "            if self.totalSupply > Decimal('0'):\n",
    "                self.rateAccumulator = ((newDebt - feeIncome) + totalPyTokens)/self.totalSupply\n",
    "                self.impliedRate = math.power(((newDebt - feeIncome) + totalPyTokens)/totalPyTokens, Decimal(1)/Decimal(total_time))\n",
    "            else:\n",
    "                self.rateAccumulator = Decimal('1')\n",
    "            self.lastUpdate = now\n",
    "    \n",
    "    def yearlyRate(self):\n",
    "        return math.power(self.impliedRate, Decimal(31622400)) - 1\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",
    "        newRate = math.power(1 + Decimal(update), 1/Decimal(31622400)) \n",
    "        self.debtRate = self.debtRate * newRate\n",
    "        if self.debtRate < Decimal(1):\n",
    "            self.debtRate = Decimal(1)\n",
    "        if self.debtRate > self.interestRateLimit:\n",
    "            self.debtRate = self.interestRateLimit\n",
    "        if self.totalDebt == 0:\n",
    "            print(\"Reseting Rates\")\n",
    "            self.debtRate = Decimal(1)\n",
    "            self.rate = Decimal(1)\n",
    "            return\n",
    "        \n",
    "        # To-DO:\n",
    "        # Update rate to be equal to rate = (debt*debtRate - fees)/(debt + reserveRatioTarget * debt)\n",
    "        \n",
    "        #calculate pyToken rate. The \"1\" in the denominator is to avoid divide by zero. Can we do this better?\n",
    "        #debt = self.getTotalDebt()\n",
    "        #self.rate = Decimal(1) + ((self.debtRate-1) * debt - self.minimumSpread)/(1 + (debt + debt*self.reservesTarget))\n",
    "        #if self.rate < Decimal(1):\n",
    "        #    self.rate = Decimal(1)\n",
    "\n",
    "    def yearlyDebtRate(self):\n",
    "        return math.power(self.debtRate, Decimal(31622400)) - 1\n",
    "    \n",
    "    def getTotalDebt(self):\n",
    "        return self.totalDebt * self.debtAccumulator\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",
    "        self.totalDebt += Decimal(amount) / self.debtAccumulator\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",
    "            self.totalDebt -= Decimal(amount) / self.debtAccumulator\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(\"repay: Cannot repay more than available debt\")\n",
    "        if amount > self.balanceOfUnderlying(address):\n",
    "            raise Exception(\"repay: Must have sufficient funds to repay.\")\n",
    "        # Decrease debt\n",
    "        result = self.burnInUnderlying(address, amount)\n",
    "        if not result:\n",
    "            raise Exception(\"repay: Burn Tokens failed\")\n",
    "        self.cdp[token][address]['debt'] = self.cdp[token][address]['debt'] - Decimal(amount) / self.debtAccumulator\n",
    "        self.totalDebt -= Decimal(amount) / self.debtAccumulator\n",
    "        assert(self.cdp[token][address]['debt'] >= 0)\n",
    "        \n",
    "    def updateRates(self):\n",
    "        if self.totalSupply == 0:\n",
    "            return\n",
    "        imbalance = self.qx.measureRatio()    \n",
    "        if imbalance > self.reservesTarget:\n",
    "            # lower interest rate\n",
    "            self.updateRate(-self.interestUpdateAmount)\n",
    "        elif imbalance < self.reservesTarget - self.adjustmentFreeWindow:\n",
    "            # raise interest rate\n",
    "            self.updateRate(self.interestUpdateAmount)\n",
    "    \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.089910089910089989391554706\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Decimal('-1')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "debtRate = Decimal(1.1)\n",
    "totalDebt = Decimal(1000)\n",
    "minimumSpread = Decimal(.1)\n",
    "totalSupply = Decimal(1000)\n",
    "\n",
    "rate = Decimal(1) + ((debtRate-1) * totalDebt * (1 - minimumSpread))/(1 + totalSupply)\n",
    "print(rate)\n",
    "-Decimal('1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "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 = QX(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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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": 14,
   "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": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "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 = QX(self.A , self.pyA)\n",
    "        self.qxB = QX(self.B , self.pyB)\n",
    "        self.pyA.setQueueExchange(self.qxA)\n",
    "        self.pyB.setQueueExchange(self.qxB)\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Agents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "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",
    "class YieldAgent(Agent):\n",
    "    def __init__(self, _interface):\n",
    "        super().__init__(_interface)\n",
    "        self.address = \"0xYA_HodlPY\" + str(self.address)\n",
    "        self.block = 0\n",
    "        \n",
    "    def setup(self):   \n",
    "        self.initialA = min(Decimal(round(numpy.random.lognormal(6, 1))), Decimal(1000))\n",
    "        self.initialB = min(Decimal(round(numpy.random.lognormal(6, 1))), Decimal(1000))\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",
    "        self.lowerRate = Decimal(numpy.random.uniform(0,7) / 100)\n",
    "        self.upperRate = self.lowerRate + Decimal(numpy.random.uniform(0,5) / 100)\n",
    "    \n",
    "    def performActions(self):\n",
    "        if self.interface.pyA.yearlyRate() > self.upperRate:\n",
    "            self.HODL()\n",
    "        elif self.interface.pyA.yearlyRate() < self.lowerRate:\n",
    "            self.unHODL()\n",
    "            \n",
    "    def HODL(self):\n",
    "        self.block = self.interface.chain.block\n",
    "        if self.interface.A.balanceOf(self.address) > 0:\n",
    "            aBalance = self.interface.A.balanceOf(self.address)\n",
    "            self.interface.qxA.mint(self.address, aBalance)\n",
    "            print(\"HODLing {} tokens at rate {}\".format(aBalance, round(self.upperRate, 4)))\n",
    "            \n",
    "    def unHODL(self):\n",
    "        if self.block - self.interface.chain.block < 10:\n",
    "            return\n",
    "        amount = min(self.interface.pyA.balanceOfUnderlying(self.address), self.interface.qxA.underlying)\n",
    "        amount = amount*Decimal('0.1')\n",
    "        if amount > 0:\n",
    "            # let's only remove 10% at a time\n",
    "            self.interface.qxA.redeem(self.address, amount)\n",
    "            print(\"unHODLing {} tokens\".format(amount*Decimal('0.99'), round(self.lowerRate, 4)))\n",
    "            \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(3, 1))), Decimal(100))\n",
    "        self.interface.eth.mint(self.address, Decimal(self.initialETH ))\n",
    "        ethReserve = self.initialETH * Decimal('0.1')\n",
    "        self.each = (self.initialETH - ethReserve)/2\n",
    "        self.interface.pyA.addCollateral(\"ETH\", self.address, self.each )\n",
    "        self.interface.pyB.addCollateral(\"ETH\", self.address, self.each )\n",
    "        price = self.interface.ethAOracle.getPriceInToken(self.interface.A)\n",
    "        self.desiredBorrow = Decimal('0.5')*self.interface.pyA.maximumBorrow(\"ETH\", self.address)\n",
    "        self.interface.A.mint(self.address, self.desiredBorrow*1000)\n",
    "        self.lowerRate = Decimal(numpy.random.uniform(0,10) / 100)\n",
    "        self.upperRate = self.lowerRate + Decimal(numpy.random.uniform(0,5) / 100)\n",
    "    \n",
    "    def performActions(self):\n",
    "        if self.interface.pyA.yearlyDebtRate() > self.upperRate:\n",
    "            self.unBorrow()\n",
    "        elif self.interface.pyA.yearlyDebtRate() < self.lowerRate:\n",
    "            self.borrow()\n",
    "        uAmount = min(self.interface.pyA.balanceOfUnderlying(self.address), self.interface.qxA.underlying)\n",
    "        if uAmount > Decimal('0.1'):\n",
    "            self.interface.qxA.redeem(self.address, uAmount*Decimal(.99))\n",
    "            print(\"Withdrew {} tokens at {}\".format(round(uAmount*Decimal(.99), 4), round(self.lowerRate, 4) ))\n",
    "            \n",
    "            \n",
    "    def borrow(self):\n",
    "        price = self.interface.ethAOracle.getPriceInToken(self.interface.A)\n",
    "        #if we've already mostly borrowed what we desire, let's stop\n",
    "        if self.interface.pyA.debtInUnderlying(\"ETH\", self.address) > Decimal('.99') * self.desiredBorrow:\n",
    "            return\n",
    "        #initiate borrow\n",
    "        borrowRatio = Decimal('0.5')\n",
    "        amount = self.interface.pyA.maximumBorrow(\"ETH\", self.address) - self.interface.pyA.debtInUnderlying(\"ETH\", self.address)\n",
    "        borrow = (amount * borrowRatio) / (self.interface.pyA.collateralizationRatio )\n",
    "        if borrow > Decimal('0.1'):\n",
    "            self.interface.pyA.borrow(\"ETH\", self.address, borrow)\n",
    "            print(\"Borrowed {} tokens at {}\".format(round(borrow, 4), round(self.lowerRate, 4) ))\n",
    "\n",
    "    \n",
    "    def unBorrow(self):\n",
    "        amount = Decimal('0.95') * self.interface.pyA.debtInUnderlying(\"ETH\", self.address)\n",
    "        #funds = self.interface.A.balanceOf(self.address)\n",
    "        #toUnBorrow = min(debt, funds)\n",
    "        if amount > Decimal('0.1'):\n",
    "            try:\n",
    "                self.interface.qxA.mint(self.address, amount*Decimal(1.01))\n",
    "                self.interface.pyA.repay(\"ETH\", self.address, amount)\n",
    "                print(\"unBorrowed {} tokens at {}\".format(round(amount, 4), round(self.upperRate, 4) ))\n",
    "            except Exception as e: \n",
    "                print(\"failed to unborrow. amount:{} underlying balance: {} pyTokens: {} \".format(amount, self.interface.A.balanceOf(self.address), self.interface.pyA.balanceOfUnderlying(self.address)))\n",
    "                raise e\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Borrowed 404.8443 tokens at 0.0619\n",
      "Borrowed 311.4187 tokens at 0.0793\n",
      "Borrowed 285.7724 tokens at 0.0619\n",
      "Borrowed 219.8250 tokens at 0.0793\n",
      "Borrowed 147.9239 tokens at 0.0282\n",
      "Borrowed 104.4169 tokens at 0.0282\n",
      "Borrowed 155.7093 tokens at 0.0977\n",
      "Borrowed 109.9125 tokens at 0.0977\n",
      "Borrowed 358.1315 tokens at 0.0490\n",
      "Borrowed 252.7987 tokens at 0.0490\n",
      "Borrowed 62.2837 tokens at 0.0835\n",
      "Borrowed 43.9650 tokens at 0.0835\n",
      "HODLing 60 tokens at rate 0.0191\n",
      "Withdrew 59.4000 tokens at 0.0619\n",
      "Withdrew 0.5940 tokens at 0.0793\n",
      "Borrowed 498.2699 tokens at 0.0891\n",
      "Borrowed 351.7199 tokens at 0.0891\n",
      "HODLing 355 tokens at rate 0.0327\n",
      "Withdrew 262.9662 tokens at 0.0977\n",
      "Withdrew 91.1194 tokens at 0.0490\n",
      "Withdrew 0.9112 tokens at 0.0835\n",
      "HODLing 149 tokens at rate 0.0359\n",
      "Withdrew 147.5191 tokens at 0.0891\n",
      "Withdrew 1.4752 tokens at 0.0619\n",
      "HODLing 207 tokens at rate 0.0399\n",
      "Withdrew 204.9448 tokens at 0.0891\n",
      "Withdrew 2.0494 tokens at 0.0619\n",
      "unBorrowed 239.7248 tokens at 0.0449\n",
      "Withdrew 239.7213 tokens at 0.0282\n",
      "Withdrew 2.3972 tokens at 0.0977\n",
      "unBorrowed 11.9862 tokens at 0.0449\n",
      "Withdrew 12.0090 tokens at 0.0282\n",
      "Withdrew 0.1201 tokens at 0.0977\n",
      "unBorrowed 0.5993 tokens at 0.0449\n",
      "Withdrew 0.6005 tokens at 0.0282\n",
      "HODLing 525 tokens at rate 0.0419\n",
      "Withdrew 0.1375 tokens at 0.0977\n",
      "Withdrew 514.6147 tokens at 0.0490\n",
      "Withdrew 10.1513 tokens at 0.0835\n",
      "Withdrew 0.1015 tokens at 0.0891\n",
      "HODLing 643 tokens at rate 0.0433\n",
      "Withdrew 2.5088 tokens at 0.0282\n",
      "Withdrew 5.1461 tokens at 0.0490\n",
      "Withdrew 94.2348 tokens at 0.0835\n",
      "Withdrew 492.4517 tokens at 0.0891\n",
      "Withdrew 48.1731 tokens at 0.0619\n",
      "Withdrew 0.4817 tokens at 0.0793\n",
      "HODLing 531 tokens at rate 0.0447\n",
      "Withdrew 525.6948 tokens at 0.0619\n",
      "Withdrew 5.2569 tokens at 0.0793\n",
      "HODLing 1000 tokens at rate 0.0458\n",
      "Withdrew 0.9423 tokens at 0.0835\n",
      "Withdrew 4.9245 tokens at 0.0891\n",
      "Withdrew 53.2892 tokens at 0.0619\n",
      "Withdrew 519.6647 tokens at 0.0793\n",
      "Withdrew 0.5329 tokens at 0.0619\n",
      "Withdrew 5.1966 tokens at 0.0793\n",
      "HODLing 409 tokens at rate 0.0461\n",
      "Borrowed 155.7093 tokens at 0.0998\n",
      "Withdrew 154.1522 tokens at 0.0998\n",
      "Borrowed 109.9125 tokens at 0.0998\n",
      "Withdrew 110.3549 tokens at 0.0998\n",
      "Withdrew 1.1035 tokens at 0.0998\n",
      "HODLing 1000 tokens at rate 0.0545\n",
      "HODLing 470 tokens at rate 0.0285\n",
      "Borrowed 38.9273 tokens at 0.0819\n",
      "Withdrew 38.5381 tokens at 0.0819\n",
      "Borrowed 27.4781 tokens at 0.0819\n",
      "Withdrew 27.5887 tokens at 0.0819\n",
      "Withdrew 0.2759 tokens at 0.0819\n",
      "Borrowed 108.9965 tokens at 0.0623\n",
      "Withdrew 107.9066 tokens at 0.0623\n",
      "Borrowed 76.9387 tokens at 0.0623\n",
      "Withdrew 77.2484 tokens at 0.0623\n",
      "Withdrew 0.7725 tokens at 0.0623\n",
      "Borrowed 482.6990 tokens at 0.0412\n",
      "Withdrew 477.8720 tokens at 0.0412\n",
      "Borrowed 340.7287 tokens at 0.0412\n",
      "Withdrew 342.1001 tokens at 0.0412\n",
      "Withdrew 3.4210 tokens at 0.0412\n",
      "HODLing 231 tokens at rate 0.0318\n",
      "HODLing 253 tokens at rate 0.0340\n",
      "Borrowed 132.3529 tokens at 0.0836\n",
      "Withdrew 131.0294 tokens at 0.0836\n",
      "Borrowed 93.4256 tokens at 0.0836\n",
      "Withdrew 93.8016 tokens at 0.0836\n",
      "Withdrew 0.9380 tokens at 0.0836\n",
      "HODLing 428 tokens at rate 0.0214\n",
      "HODLing 137 tokens at rate 0.0317\n",
      "Borrowed 70.0692 tokens at 0.0821\n",
      "Withdrew 69.3685 tokens at 0.0821\n",
      "Borrowed 49.4606 tokens at 0.0821\n",
      "Withdrew 49.6597 tokens at 0.0821\n",
      "Withdrew 0.4966 tokens at 0.0821\n",
      "Borrowed 46.7128 tokens at 0.0398\n",
      "Withdrew 46.2457 tokens at 0.0398\n",
      "Borrowed 32.9737 tokens at 0.0398\n",
      "Withdrew 33.1065 tokens at 0.0398\n",
      "Withdrew 0.3311 tokens at 0.0398\n",
      "Borrowed 116.7820 tokens at 0.0933\n",
      "Withdrew 115.6142 tokens at 0.0933\n",
      "Borrowed 82.4344 tokens at 0.0933\n",
      "Withdrew 82.7662 tokens at 0.0933\n",
      "Withdrew 0.8277 tokens at 0.0933\n",
      "Borrowed 272.4913 tokens at 0.0801\n",
      "Withdrew 269.7664 tokens at 0.0801\n",
      "HODLing 138 tokens at rate 0.0388\n",
      "Borrowed 192.3468 tokens at 0.0801\n",
      "Withdrew 193.1210 tokens at 0.0801\n",
      "Withdrew 1.9312 tokens at 0.0801\n",
      "HODLing 863 tokens at rate 0.0445\n",
      "HODLing 1000 tokens at rate 0.0317\n",
      "Borrowed 93.4256 tokens at 0.0522\n",
      "Withdrew 92.4913 tokens at 0.0522\n",
      "Borrowed 65.9475 tokens at 0.0522\n",
      "Withdrew 66.2129 tokens at 0.0522\n",
      "Withdrew 0.6621 tokens at 0.0522\n",
      "HODLing 994 tokens at rate 0.0246\n",
      "HODLing 452 tokens at rate 0.0145\n",
      "Borrowed 101.2111 tokens at 0.0377\n",
      "Withdrew 100.1990 tokens at 0.0377\n",
      "Borrowed 71.4431 tokens at 0.0377\n",
      "Withdrew 71.7307 tokens at 0.0377\n",
      "Withdrew 0.7173 tokens at 0.0377\n",
      "Borrowed 498.2699 tokens at 0.0506\n",
      "Withdrew 493.2872 tokens at 0.0506\n",
      "Borrowed 351.7199 tokens at 0.0506\n",
      "Withdrew 353.1356 tokens at 0.0506\n",
      "Withdrew 3.5314 tokens at 0.0506\n",
      "Borrowed 147.9146 tokens at 0.0282\n",
      "Withdrew 146.4605 tokens at 0.0282\n",
      "Borrowed 104.4103 tokens at 0.0282\n",
      "Withdrew 104.8308 tokens at 0.0282\n",
      "Withdrew 1.0483 tokens at 0.0282\n",
      "Borrowed 264.7059 tokens at 0.0880\n",
      "Withdrew 262.0588 tokens at 0.0880\n",
      "Borrowed 186.8512 tokens at 0.0880\n",
      "Withdrew 187.6033 tokens at 0.0880\n",
      "Withdrew 1.8760 tokens at 0.0880\n",
      "Borrowed 93.4256 tokens at 0.0230\n",
      "Withdrew 92.4913 tokens at 0.0230\n",
      "Borrowed 65.9475 tokens at 0.0230\n",
      "Withdrew 66.2129 tokens at 0.0230\n",
      "Withdrew 0.6621 tokens at 0.0230\n"
     ]
    }
   ],
   "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",
    "interface.pyA.interestUpdateAmount = Decimal('0.0001')\n",
    "interface.pyA.reservesTarget = Decimal('0.25')\n",
    "interface.pyA.minimumSpread = Decimal('0.0')\n",
    "interface.pyA.adjustmentFreeWindow = Decimal('0.01')\n",
    "\n",
    "# tracking variables\n",
    "pyAinterest = []\n",
    "pyBinterest = []\n",
    "qxA = []\n",
    "qxB = []\n",
    "pyratesA = []\n",
    "debtratesA = []\n",
    "tSupply = []\n",
    "ulying = []\n",
    "debtOutstanding = []\n",
    "debtSupplyRatio = []\n",
    "feeIncome = []\n",
    "\n",
    "\n",
    "\n",
    "# Initial positions\n",
    "interface.A.mint(\"HODL\", Decimal(100000))\n",
    "interface.B.mint(\"HODL\", Decimal(100000))\n",
    "interface.eth.mint(\"BU\", Decimal(1000))\n",
    "interface.pyA.addCollateral(\"ETH\", \"BU\", Decimal(100) )\n",
    "interface.pyB.addCollateral(\"ETH\", \"BU\", Decimal(100) )\n",
    "\n",
    "price = interface.ethAOracle.getPriceInToken(interface.A)\n",
    "#borrow = (Decimal(25) * price) / (interface.pyA.collateralizationRatio )\n",
    "#borrow = Decimal(100)\n",
    "#interface.pyA.borrow(\"ETH\", \"BU\", borrow)\n",
    "#interface.qxA.mint(\"HODL\", Decimal(1500 * 0.15))\n",
    "\n",
    "#Create users\n",
    "\n",
    "#user1 = YieldAgent(interface)\n",
    "#user2 = BorrowAgent(interface)\n",
    "#users = [user1, user2]\n",
    "\n",
    "users = []\n",
    "for x in range(5):\n",
    "    users.append(YieldAgent(interface))\n",
    "    \n",
    "for y in range(2):\n",
    "    users.append(BorrowAgent(interface))\n",
    "\n",
    "# Setup\n",
    "for user in users:\n",
    "    user.setup()\n",
    "\n",
    "# Run\n",
    "for block in range(10000):\n",
    "    \n",
    "    # skip some blocks\n",
    "    if numpy.random.uniform(0,100) < 80:\n",
    "        continue\n",
    "    \n",
    "    # perform interest rate update at beginning of block\n",
    "    interface.eachBlock()\n",
    "    \n",
    "    # add users\n",
    "    if numpy.random.uniform(0,100) < 4:\n",
    "        if numpy.random.uniform(0,100) < 33:\n",
    "            newAgent = BorrowAgent(interface)\n",
    "            newAgent.setup()\n",
    "            users.append(newAgent)\n",
    "        else:\n",
    "            newAgent = YieldAgent(interface)\n",
    "            newAgent.setup()\n",
    "            users.append(newAgent)\n",
    "    \n",
    "    for user in users:\n",
    "        user.performActions()\n",
    "    \n",
    "    pyAinterest.append(float(interface.pyA.yearlyRate()))\n",
    "    debtSupplyRatio.append(float(interface.pyA.totalDebt/interface.pyA.totalSupply))\n",
    "    qxA.append(float(interface.qxA.measureRatio()))\n",
    "    debtOutstanding.append(float(interface.pyA.getTotalDebt()))\n",
    "    pyratesA.append(float(interface.pyA.yearlyRate()))\n",
    "    debtratesA.append(float(interface.pyA.yearlyDebtRate()))\n",
    "    tSupply.append(float(interface.pyA.totalSupply))\n",
    "    ulying.append(float(interface.qxA.underlying))\n",
    "    feeIncome.append(float(interface.pyA.totalFeeIncome))\n",
    "# Shutdown\n",
    "for user in users:\n",
    "    user.shutdown()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11c10e890>"
      ]
     },
     "execution_count": 19,
     "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(debtOutstanding, name=\"debt\").plot(legend=True)\n",
    "pandas.Series(tSupply, name=\"pyTokens\").plot(legend=True)\n",
    "pandas.Series(ulying, name=\"underlying\").plot(legend=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11eba76d0>"
      ]
     },
     "execution_count": 20,
     "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(debtSupplyRatio, name=\"Debt/Supply Ratio\").plot(legend=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11ead7c50>"
      ]
     },
     "execution_count": 21,
     "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, name=\"Reserve Ratio\").plot(legend=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x10cf93b10>"
      ]
     },
     "execution_count": 22,
     "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(pyratesA, name=\"pyToken yield\").plot(legend=True)\n",
    "pandas.Series(debtratesA,name=\"borrow rate\").plot(legend=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's look at variance\n",
    "pandas.Series(pyratesA[1000:], name=\"pyToken yield\").var()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pandas.Series(feeIncome,name=\"fee income\").plot(legend=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Scratchpad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "interface.A.balances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "interface.pyA.balances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numpy.random.lognormal(5, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lnmean(mean, sigma):\n",
    "    sum = 0\n",
    "    for x in range(1000):\n",
    "        sum += numpy.random.lognormal(mean, sigma)\n",
    "    return sum/1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lnmean(.1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lnmean(6,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def threshold(mean, sigma, limit ):\n",
    "    result = int(numpy.random.exponential(mean))\n",
    "    print(result)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tfreq(mean, sigma, limit):\n",
    "    sum = 0\n",
    "    for x in range(100):\n",
    "        if threshold(mean, sigma, limit ):\n",
    "            sum += 1\n",
    "    return sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numpy.random.exponential(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interest Tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# self.rate = Decimal(1) + ((self.debtRate-1) * self.totalDebt * (1 - self.minimumSpread))/(1 + self.totalSupply)\n",
    "# self.rate = math.power(1 + Decimal(rate), 1/Decimal(31622400)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from decimal import Decimal\n",
    "import decimal\n",
    "debtRate = Decimal('1.04')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math = decimal.Context()\n",
    "accumulate = math.power(debtRate, 2)\n",
    "accumulate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "minSpread = Decimal('0.00')\n",
    "totalSupply = 1000\n",
    "totalDebt = totalSupply * Decimal('0.7')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rate = Decimal(1) + ((debtRate-1) * totalDebt * (1 - minSpread))/(totalSupply)\n",
    "#rate = ((debtRate) * totalDebt * (1 - minSpread))/(1 + totalSupply)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.power(rate, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "accumulate*totalDebt - totalDebt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "totalSupply*math.power(rate, 2) - totalSupply"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(totalDebt*math.power(debtRate, 10))\n",
    "print(totalSupply*math.power(Decimal('1.02'), 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('1.000000000003162157215564487')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "interestUpdateAmount = Decimal('0.0001')\n",
    "newRate = math.power(1 + Decimal(interestUpdateAmount), 1/Decimal(31622400))\n",
    "newRate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0000000000031621"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1000000000003162157215564487 / 10**27"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000000284625770972959474870"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(3162157215564487 * 90010) + 10**27\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2000000000000000000000000000"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2*10**27"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "4.999999999999998706\n",
    "4.999999999999999000"
   ]
  }
 ],
 "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
}