src/test_src.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import libraries\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import scipy.stats as sts\n",
    "import seaborn as sns\n",
    "\n",
    "%matplotlib inline\n",
    "from bonding_curve_eq import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## System Initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "money_raised = 1000 # money raised in fiat, m\n",
    "fiat_price = .1 # fiat per tokens, P_i\n",
    "rho0 = .5 # reserve ratio\n",
    "\n",
    "R0 = rho0*money_raised # initial reserve\n",
    "S0 = money_raised/fiat_price # initial supply\n",
    "\n",
    "kappa0 = 1/rho0 # curvature of bonding curve\n",
    "alpha0 = 1 - rho0 # initial alpha\n",
    "V0 = invariant_V0(R0, S0, kappa0)\n",
    "P0 = spot_price(R0, V0, kappa0)\n",
    "\n",
    "S_pos = 0 # supply tokens bonded to positive attestation, S_omega=1\n",
    "S_neg = 0 # supply tokens bonded to negative attestation, S_omega=0\n",
    "\n",
    "commitment = 800 # impact payers' payout commitment, C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Agent Initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "alpha_belief = alpha0 # agent's private belief of alpha, omega\n",
    "price_belief = P0 # agent's private belief of price, p_i\n",
    "\n",
    "attestations_pos = 0 # positive attestations held by agent, Q_omega=1\n",
    "attestations_neg = 0 # negative attestations held by agent, Q_omega=0\n",
    "\n",
    "#param for open loop\n",
    "rules = [\"martin\", \"step\",\"ramp\", \"sin\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "params = {\n",
    "    'kappa': [kappa0],\n",
    "    'alpha': [alpha0],\n",
    "    'invariant_V0': [V0],\n",
    "    'invariant_I0': [I0],\n",
    "    'rule' : rules,\n",
    "    'dP' : ['N/A', P0/4, P0/1000, P0/2],\n",
    "    'period': ['N/A', 2000,2000,2000]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial Conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "initial_conditions = {'reserve': R0,\n",
    "                      'supply': S0,\n",
    "                      'price': P0,\n",
    "                      'spot_price': P0,\n",
    "                      'alpha': alpha0,\n",
    "                      'spot_alpha': alpha0,\n",
    "                      'rho': rho0\n",
    "                      }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_action(params, step, sL, s):\n",
    "    \n",
    "    R = s['reserve']\n",
    "    S = s['supply']\n",
    "    V0 = params['invariant_V0']\n",
    "    P = s['spot_price']\n",
    "    alpha = s['spot_alpha']\n",
    "    period = params['period']\n",
    "    \n",
    "    if params['rule'] == 'sin':\n",
    "        new_price = P0 + params['dP']*np.sin(2*np.pi*s['timestep']/period)\n",
    "        print(\"new_price = \", new_price)\n",
    "        \n",
    "    if P > price_belief_a:\n",
    "        mech = 'burn'\n",
    "    elif P < price_belief_a:\n",
    "        mech = 'bond'\n",
    "    else: \n",
    "        # don't trade \n",
    "        print(\"No trade\")\n",
    "        \n",
    "    \n",
    "    if alpha > alpha_belief_a:\n",
    "        mech = 'attest_neg'\n",
    "    elif alpha < alpha_belief_a:\n",
    "        mech = 'attest_pos'\n",
    "    else:\n",
    "        # don't attest\n",
    "        print(\"No attestation\")\n",
    "        \n",
    "    ####### Any syntax related changes required here? #######\n",
    "    # design pattern for action\n",
    "    \n",
    "    action = {\n",
    "                'mech':mech, \n",
    "                'amt_b':amt_b,\n",
    "                'amt_a':amt_a,\n",
    "                'p_in':new_price,\n",
    "                'price_belief':price_belief(amt_b),\n",
    "                'alpha_in': new_alpha,\n",
    "                'alpha_belief': alpha_belief(amt_a),\n",
    "                'posterior':{}\n",
    "    }\n",
    "    \n",
    "    if action['mech'] == 'bond':\n",
    "\n",
    "        dS, price_belief = mint(amt_b, R, S, V0, params['kappa'])\n",
    "        R = R + amt_b\n",
    "        S = S + dS\n",
    "        P = spot_price(R, V0, kappa)\n",
    "\n",
    "    elif action['mech'] == 'burn':\n",
    "        dR, price_belief = withdraw(amt_b, R, S, V0, params['kappa'])\n",
    "        R = R - dR\n",
    "        S = S - amt_b\n",
    "        P = spot_price(R, V0, kappa)\n",
    "        \n",
    "    if action['mech'] == 'attest_pos':\n",
    "        \n",
    "        dQ1, alpha_belief = attest_pos(amt_a, S1, C, I0, params['kappa'])\n",
    "        S1 = S1 + amt_a\n",
    "        Q1 = Q1 + dQ1\n",
    "        alpha = spot_alpha(S, I0, kappa, C)\n",
    "    \n",
    "    elif action['mech'] == 'attest_neg':\n",
    "        \n",
    "        dQ0, alpha_belief = attest_neg(amt_a, S0, C, I0, params['kappa'])\n",
    "        S0 = S0 + amt_a\n",
    "        Q0 = Q0 + dQ0\n",
    "        alpha = spot_alpha(S, I0, kappa, C)\n",
    "    \n",
    "    \n",
    "    action['posterior'] = {'S':S, 'R':R,'P':P, 'S1':S1, 'Q1':Q1, 'S2':S2, 'Q2':Q2, 'alpha':alpha}\n",
    "    \n",
    "    return {'action': action}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_action(params, step, sL, s):\n",
    "    \n",
    "    R = s['reserve']\n",
    "    S = s['supply']\n",
    "    V = params['invariant_V']\n",
    "    I = params['invariant_I']\n",
    "    P = s['spot_price']\n",
    "    alpha = s['spot_alpha']\n",
    "    kappa = params['kappa']\n",
    "    period = params['period']\n",
    "    \n",
    "    if params['rule'] == 'sin':\n",
    "        new_price = P0 + params['dP']*np.sin(2*np.pi*s['timestep']/period)\n",
    "        print(\"new_price = \", new_price)\n",
    "        \n",
    "    if P > price_belief_a:\n",
    "        mech = 'burn'\n",
    "    elif P < price_belief_a:\n",
    "        mech = 'bond'\n",
    "    else: \n",
    "        # don't trade \n",
    "        print(\"No trade\")\n",
    "        \n",
    "    \n",
    "    if alpha > alpha_belief_a:\n",
    "        mech = 'attest_neg'\n",
    "    elif alpha < alpha_belief_a:\n",
    "        mech = 'attest_pos'\n",
    "    else:\n",
    "        # don't attest\n",
    "        print(\"No attestation\")\n",
    "    \n",
    "    action = {\n",
    "                'mech':mech, \n",
    "                'amt_b':amt_b,\n",
    "                'amt_a':amt_a,\n",
    "                'p_in':new_price,\n",
    "                'price_belief':price_belief(amt_b),\n",
    "                'alpha_in': new_alpha,\n",
    "                'alpha_belief': alpha_belief(amt_a),\n",
    "                'posterior':{}\n",
    "    }\n",
    "    \n",
    "    if action['mech'] == 'bond':\n",
    "        dS, price_belief = bond(amt_b, R, S, V, params['kappa'])\n",
    "        R = R + amt_b\n",
    "        S = S + dS\n",
    "        I = R + (C*alpha)\n",
    "        kappa = kappa(deltaR, R, S, V, I, alpha)\n",
    "        P = spot_price(R, V, kappa)\n",
    "        \n",
    "\n",
    "    elif action['mech'] == 'burn':\n",
    "        dR, price_belief = withdraw(amt_b, R, S, V, params['kappa'])\n",
    "        R = R - dR\n",
    "        S = S - amt_b\n",
    "        I = R + (C*alpha)\n",
    "        kappa = kappa(dR, R, S, V, I, alpha)\n",
    "        P = spot_price(R, V, kappa)\n",
    "        \n",
    "    if action['mech'] == 'attest_pos':      \n",
    "        dQ1, alpha_belief = attest_pos(amt_a, S1, C, I, params['kappa'])\n",
    "        S1 = S1 + amt_a\n",
    "        Q1 = Q1 + dQ1\n",
    "        alpha = spot_alpha(S, I, kappa, C)\n",
    "        kappa = kappa(dR, R, S, V, I, alpha)\n",
    "        P = spot_price()\n",
    "        V = invariant_V(R, S, kappa)\n",
    "    \n",
    "    elif action['mech'] == 'attest_neg':       \n",
    "        dQ0, alpha_belief = attest_neg(amt_a, S0, C, I, params['kappa'])\n",
    "        S0 = S0 + amt_a\n",
    "        Q0 = Q0 + dQ0\n",
    "        alpha = spot_alpha(S, I, kappa, C)\n",
    "        kappa = kappa(dR, R, S, V, I, alpha)\n",
    "        P = spot_price()\n",
    "        V = invariant_V(R, S, kappa)\n",
    "    \n",
    "    action['posterior'] = {'S':S, 'R':R, 'P':P, 'S1':S0, 'S1':S1, 'Q0':Q0, 'Q1':Q1, 'kappa':kappa, 'alpha':alpha, 'I':I, 'V':V}\n",
    "    \n",
    "    return {'action': action}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_S(params, step, sL, s, _input):\n",
    "    \n",
    "    action = _input['action']\n",
    "    S = action['posterior']['S']\n",
    "    \n",
    "    key = 'supply'\n",
    "    value = S\n",
    "    \n",
    "    return (key, value)\n",
    "\n",
    "def update_R(params, step, sL, s, _input):\n",
    "    \n",
    "    action = _input['action']\n",
    "    R = action['posterior']['R']\n",
    "    \n",
    "    key = 'reserve'\n",
    "    value = R\n",
    "    \n",
    "    return (key, value)\n",
    "\n",
    "def update_P(params, step, sL, s, _input):\n",
    "    \n",
    "    action = _input['action']\n",
    "    P = action['posterior']['P']\n",
    "    \n",
    "    key = 'spot_price'\n",
    "    value = P\n",
    "    \n",
    "    return (key, value)\n",
    "\n",
    "def update_price_belief(params, step, sL, s, _input):\n",
    "    \n",
    "    action = _input['action']\n",
    "    price_belief = action['price_belief']\n",
    "    \n",
    "    key = 'output_price'\n",
    "    value = price_belief\n",
    "    \n",
    "    return (key, value)\n",
    "\n",
    "def capture_P_in(params, step, sL, s, _input):\n",
    "    \n",
    "    P_in = _input['action']['p_in']\n",
    "    if P_in == 0:\n",
    "        print(_input['action']) \n",
    "    \n",
    "    key = 'price'\n",
    "    value = P_in\n",
    "    \n",
    "    return (key, value)\n",
    "\n",
    "def update_alpha_belief(params, step, sL, s, _input):\n",
    "    \n",
    "    action = input['action']\n",
    "    alpha_belief = action['alpha_belief']\n",
    "    \n",
    "    key = 'output_alpha'\n",
    "    value = alpha_belief\n",
    "    \n",
    "    return (key, value)\n",
    "\n",
    "def capture_alpha_in(params, step, sL, s, _input):\n",
    "    \n",
    "    alpha_in = _input['action']['alpha_in']\n",
    "    if alpha_in == 0:\n",
    "        print(_input['action']) \n",
    "    \n",
    "    key = 'alpha'\n",
    "    value = alpha_in\n",
    "    \n",
    "    return (key, value)"
   ]
  }
 ],
 "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": 4
}