adiasg/confirmation-rule.ipynb

## confirmation-rule.ipynb
{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9c6dbc4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import httpx\n",
    "import json\n",
    "import time\n",
    "import eth2spec.capella.mainnet as spec\n",
    "import pprint\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "cd4a196d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pp(json_obj):\n",
    "    pprint.pprint(json_obj, sort_dicts=False)\n",
    "\n",
    "def query_beacon_api(endpoint, extra_headers={}, params={}):\n",
    "    r = httpx.get(BEACON_API_ENDPOINT+endpoint, headers=headers|extra_headers, params=params)\n",
    "    assert r.status_code == httpx.codes.OK, f\"beacon-API for {endpoint} responded with code {r.status_code}\"\n",
    "    return r.json()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "42944f6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_current_slot():\n",
    "    # Returns the current slot. Requires GENESIS_TIME to be set appropriately.\n",
    "    current_time = time.time()\n",
    "    current_slot = int(current_time - GENESIS_TIME) // spec.config.SECONDS_PER_SLOT\n",
    "    return int(current_slot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a09ac8fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def query_fc_info():\n",
    "    # Queries the beacon-API for all necessary information for confirmation rule. Returns fc_info object as below.\n",
    "    head_block_header = query_beacon_api('/eth/v1/beacon/headers/head')\n",
    "    fork_choice_context = query_beacon_api('/eth/v1/debug/fork_choice')\n",
    "    current_slot = get_current_slot()\n",
    "    head_committee = query_beacon_api('/eth/v1/beacon/states/head/committees', params={'slot': current_slot})\n",
    "    \n",
    "    nodes = {}\n",
    "    for node in fork_choice_context['fork_choice_nodes']:\n",
    "        block_root = node['block_root']\n",
    "        nodes[block_root] = node\n",
    "    \n",
    "    committee_size = 0\n",
    "    for comm in head_committee['data']:\n",
    "        committee_size += len(comm['validators'])\n",
    "    committee_size\n",
    "    \n",
    "    fc_info = {\n",
    "        'current_slot': current_slot,\n",
    "        'justified_checkpoint': fork_choice_context['justified_checkpoint'],\n",
    "        'finalized_checkpoint': fork_choice_context['finalized_checkpoint'],\n",
    "        'nodes': nodes,\n",
    "        'head_root': head_block_header['data']['root'],\n",
    "        'committee_size': committee_size,\n",
    "    }\n",
    "                                      \n",
    "    return fc_info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "075fe876",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check the FFG safety of a block\n",
    "\n",
    "def get_ancestor(block_root, slot, fc_info):\n",
    "    # Returns the root of the highest ancestor block at or below the requested slot\n",
    "    nodes = fc_info['nodes']\n",
    "    node = nodes[block_root]\n",
    "    while int(node['slot']) > slot:\n",
    "        parent_root = node['parent_root']\n",
    "        node = nodes[parent_root]\n",
    "    return node['block_root']\n",
    "\n",
    "def get_highest_checkpoint_block(block_root, fc_info):\n",
    "    # Return the root of the highest checkpoint block in the block's chain\n",
    "    nodes = fc_info['nodes']\n",
    "    node = nodes[block_root]\n",
    "    block_slot = int(node['slot'])\n",
    "    checkpoint_slot = block_slot - (block_slot % int(spec.SLOTS_PER_EPOCH))\n",
    "    checkpoint_root = get_ancestor(block_root, checkpoint_slot, fc_info)\n",
    "    return checkpoint_root\n",
    "\n",
    "def get_checkpoint_ffg_support(block_root, fc_info):\n",
    "    # Returns the FFG support for the highest checkpoint block in the block's chain\n",
    "    nodes = fc_info['nodes']\n",
    "    checkpoint_root = get_highest_checkpoint_block(block_root, fc_info)\n",
    "    node = nodes[checkpoint_root]\n",
    "    return int(node['weight'])\n",
    "\n",
    "def get_total_validators_weight(fc_info):\n",
    "    # Returns the weight of the entire validator set\n",
    "    committee_size = int(fc_info['committee_size'])\n",
    "    return int(spec.SLOTS_PER_EPOCH) * committee_size * VALIDATOR_BALANCE\n",
    "\n",
    "def get_remaining_weight_in_epoch(fc_info):\n",
    "    # Returns the weight of validators yet to vote in the current epoch\n",
    "    current_slot = fc_info['current_slot']\n",
    "    committee_size = int(fc_info['committee_size'])\n",
    "    remaining_slots_in_epoch = int(spec.SLOTS_PER_EPOCH) - (current_slot % int(spec.SLOTS_PER_EPOCH))\n",
    "    return remaining_slots_in_epoch * committee_size * VALIDATOR_BALANCE\n",
    "\n",
    "def max_beta_ffg(block_root, fc_info):\n",
    "    # Returns the maximum beta possible from the FFG safety conditions for the requested block\n",
    "    nodes = fc_info['nodes']\n",
    "    node = nodes[block_root]\n",
    "    block_slot = int(node['slot'])\n",
    "    block_epoch = spec.compute_epoch_at_slot(block_slot)\n",
    "    current_slot = fc_info['current_slot']\n",
    "    current_epoch = spec.compute_epoch_at_slot(current_slot)\n",
    "    assert block_epoch == current_epoch\n",
    "    checkpoint_ffg_support = get_checkpoint_ffg_support(block_root, fc_info)\n",
    "    total_validators_weight = get_total_validators_weight(fc_info)\n",
    "    remaining_weight_in_epoch = get_remaining_weight_in_epoch(fc_info)\n",
    "    return 1 - (((2 / 3) * total_validators_weight - checkpoint_ffg_support) / remaining_weight_in_epoch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4efad668",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check the LMD safety of a block\n",
    "\n",
    "def get_max_weight(slot, fc_info):\n",
    "    # Fetches the total weight that can support a block at the requested slot\n",
    "    \n",
    "    # Ensure that the requested slot is in the current or previous epoch\n",
    "    current_slot = int(fc_info['current_slot'])\n",
    "    committee_size = int(fc_info['committee_size'])\n",
    "    current_epoch = spec.compute_epoch_at_slot(current_slot)\n",
    "    \n",
    "    epoch_start_slot = int(spec.compute_start_slot_at_epoch(current_epoch))\n",
    "    if slot >= epoch_start_slot:\n",
    "        # For each committee from the current epoch, add the weight of a full committee\n",
    "        comms = current_slot - slot\n",
    "    elif slot >= epoch_start_slot - spec.SLOTS_PER_EPOCH:\n",
    "        # For each committee from the current epoch, add the weight of a full committee\n",
    "        comms = current_slot - epoch_start_slot\n",
    "        # For each committee from the previous epoch, add the prorated weight of a committee according to \n",
    "        # the ratio of validators yet to vote in the current epoch\n",
    "        remaining_slots_in_epoch = spec.SLOTS_PER_EPOCH - (current_slot % spec.SLOTS_PER_EPOCH)\n",
    "        multiplier = int(remaining_slots_in_epoch) / int(spec.SLOTS_PER_EPOCH)\n",
    "        comms += multiplier * int(epoch_start_slot - slot)\n",
    "    else:\n",
    "        # If the slot is more than 2 epochs ago, add the weight of all committees\n",
    "        comms = int(spec.SLOTS_PER_EPOCH)\n",
    "    return comms * committee_size * VALIDATOR_BALANCE\n",
    "\n",
    "def q(block_root, fc_info):\n",
    "    # Returns the actual q and minimum safe q values for the requested block\n",
    "    nodes = fc_info['nodes']\n",
    "    node = nodes[block_root]\n",
    "    support = int(node['weight'])\n",
    "    \n",
    "    parent_root = nodes[block_root]['parent_root']\n",
    "    parent_slot = int(nodes[parent_root]['slot'])\n",
    "    max_weight = get_max_weight(parent_slot, fc_info)\n",
    "    \n",
    "    committee_size = int(fc_info['committee_size'])\n",
    "    proposer_boost_weight = (int(spec.config.PROPOSER_SCORE_BOOST) / 100) * committee_size * VALIDATOR_BALANCE\n",
    "    min_safe_q = 0.5 * (1 + proposer_boost_weight/max_weight)\n",
    "    return support/max_weight, min_safe_q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "2c5ac49c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check the LMD safety for a branch\n",
    "\n",
    "def compute_q_for_nodes(nodes, fc_info):\n",
    "    # Computes q values for the requested nodes, and fills in the q vaules in the nodes themselves.\n",
    "    for root in nodes.keys():\n",
    "        node = nodes[root]\n",
    "        q_vals = q(node['block_root'], fc_info)\n",
    "        node['q'] = q_vals[0]\n",
    "        node['min_safe_q'] = q_vals[1]\n",
    "    return nodes\n",
    "\n",
    "def get_canonical_branch(fc_info):\n",
    "    # Returns the nodes in the canonical branch, given an fc_info object\n",
    "    root = fc_info['head_root']\n",
    "    nodes = fc_info['nodes']\n",
    "    canonical_branch = {}\n",
    "    while True:\n",
    "        canonical_branch[root] = nodes[root]\n",
    "        if root == fc_info['justified_checkpoint']['root']:\n",
    "            break\n",
    "        root = nodes[root]['parent_root']\n",
    "    return canonical_branch\n",
    "\n",
    "def get_canonical_branch_with_q():\n",
    "    # Computes the canonical branch with q values from scratch\n",
    "    fc_info = query_fc_info()\n",
    "    # Ensure that the justified checkpoint is from the previous epoch\n",
    "    current_epoch = spec.compute_epoch_at_slot(fc_info['current_slot'])\n",
    "    justified_epoch = int(fc_info['justified_checkpoint']['epoch'])\n",
    "    assert justified_epoch == current_epoch - 1\n",
    "    \n",
    "    canonical_branch = get_canonical_branch(fc_info)\n",
    "    compute_q_for_nodes(canonical_branch, fc_info)\n",
    "    return canonical_branch, fc_info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0feee9f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_q_for_branch(branch, fc_info):\n",
    "    # Plots the q values for the given branch\n",
    "    \n",
    "    # Compute the max beta value for FFG safety of the current epoch checkpoint\n",
    "    # in the canonical chain\n",
    "    head_root = fc_info['head_root']\n",
    "    max_beta = min(0.33, max_beta_ffg(head_root, fc_info))\n",
    "    \n",
    "    # Construct the x & y lists\n",
    "    slots = []\n",
    "    qs = []\n",
    "    min_safe_qs = []\n",
    "    nodes = branch\n",
    "    for root in canonical_branch.keys():\n",
    "        node = nodes[root]\n",
    "        slot = int(node['slot'])\n",
    "        slots.append(slot)\n",
    "        qs.append(float(node['q']))\n",
    "        min_safe_qs.append(float(node['min_safe_q']))\n",
    "    \n",
    "    # Resize the figure for better viewing\n",
    "    plt.rcParams[\"figure.figsize\"] = [10, 5]\n",
    "    # Add title & axis labels\n",
    "    plt.title(f\"q values for the canonical branch\")\n",
    "    plt.xlabel(f\"Slot # of block\\n\\n\"+\n",
    "               f\"Current slot = {fc_info['current_slot']}\\n\"+\n",
    "               r\"$\\beta$\" + f\" for FFG safety of checkpoint block = {round(max_beta, 2)}\")\n",
    "    plt.ylabel(\"q\")\n",
    "    \n",
    "    # Plot line graph for q\n",
    "    plt.plot(slots, qs, marker='.', label='q')\n",
    "    # Plot line graph for min_safe_q\n",
    "    plt.plot(slots, min_safe_qs, color='red', label='min. safe q')\n",
    "    plt.legend()\n",
    "\n",
    "    # Add shading for previous epoch\n",
    "    current_slot = fc_info['current_slot']\n",
    "    current_epoch = spec.compute_epoch_at_slot(current_slot)\n",
    "    epoch_start_slot = spec.compute_start_slot_at_epoch(current_epoch)\n",
    "    x_lower_lim = plt.xlim()[0]\n",
    "    plt.axvspan(x_lower_lim, epoch_start_slot, color='0.8', alpha=0.5)\n",
    "    \n",
    "    # Annotate the current epoch checkpoint\n",
    "    checkpoint_root = get_highest_checkpoint_block(head_root, fc_info)\n",
    "    checkpoint_x = int(nodes[checkpoint_root]['slot'])\n",
    "    checkpoint_y = nodes[checkpoint_root]['q']\n",
    "    plt.annotate('Checkpoint Block', \n",
    "                xy=(checkpoint_x, checkpoint_y), \n",
    "                xytext=(-150,-50), textcoords='offset pixels',\n",
    "                arrowprops=dict(facecolor ='green', headlength=10),)\n",
    "    \n",
    "    # Format the ticks\n",
    "    plt.xticks(slots, rotation=90)\n",
    "    plt.ticklabel_format(useOffset=False, style='plain')\n",
    "    plt.ylim(0, 1.05)\n",
    "    plt.yticks([i/10 for i in range(11)])\n",
    "    # Show gridlines\n",
    "    plt.grid()\n",
    "    # Display plot\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7309e923",
   "metadata": {},
   "outputs": [],
   "source": [
    "BEACON_API_ENDPOINT = 'your-beacon-api'\n",
    "VALIDATOR_BALANCE = 32 * (10**9)\n",
    "genesis = query_beacon_api('/eth/v1/beacon/genesis')\n",
    "GENESIS_TIME = int(genesis['data']['genesis_time'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "caad0fba",
   "metadata": {},
   "outputs": [],
   "source": [
    "canonical_branch, fc_info = get_canonical_branch_with_q()\n",
    "head_root = fc_info['head_root']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5a5eb666",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_q_for_branch(canonical_branch, fc_info)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "eth-conf-rule",
   "language": "python",
   "name": "eth-conf-rule"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}