diff --git a/cryptarchia/longest-chain-cryptarchia.ipynb b/cryptarchia/longest-chain-cryptarchia.ipynb index b61b5f6..8fd5818 100644 --- a/cryptarchia/longest-chain-cryptarchia.ipynb +++ b/cryptarchia/longest-chain-cryptarchia.ipynb @@ -2,21 +2,22 @@ "cells": [ { "cell_type": "code", - "execution_count": 31, + "execution_count": 1, "id": "ad657d5a-bd36-4329-b134-6745daff7ae9", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "from dataclasses import dataclass\n", + "from dataclasses import dataclass, replace\n", "from pyvis.network import Network\n", - "from pyvis.options import Layout" + "from pyvis.options import Layout\n", + "import time" ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 2, "id": "a9e0b910-c633-4dbe-827c-4ddb804f7a9a", "metadata": {}, "outputs": [], @@ -27,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 3, "id": "aa0aadce-a0be-4873-ba23-293be74db313", "metadata": {}, "outputs": [], @@ -43,23 +44,33 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 4, "id": "a538cf45-d551-4603-b484-dbbc3f3d0a73", "metadata": {}, "outputs": [], "source": [ "@dataclass\n", "class NetworkParams:\n", - " mixnet_delay_mean: int # seconds\n", - " mixnet_delay_var: int\n", " broadcast_delay_mean: int # second\n", " pol_proof_time: int # seconds\n", + " # ---- blend network -- \n", + " blending_delay: int\n", + " desimenation_delay_mean: float\n", + " # desimenation_delay_var: float\n", + " blend_hops: int\n", " no_network_delay: bool = False\n", "\n", - " def sample_mixnet_delay(self):\n", - " scale = self.mixnet_delay_var / self.mixnet_delay_mean\n", - " shape = self.mixnet_delay_mean / scale\n", - " return np.random.gamma(shape=shape, scale=scale)\n", + " def sample_blending_delay(self):\n", + " return np.random.uniform(0, self.blending_delay)\n", + "\n", + " def sample_desimenation_delay(self):\n", + " return np.random.exponential(self.desimenation_delay_mean)\n", + " # scale = self.desimenation_delay_var / self.desimenation_delay_mean\n", + " # shape = self.desimenation_delay_mean / scale\n", + " # return np.random.gamma(shape=shape, scale=scale)\n", + "\n", + " def sample_blend_network_delay(self):\n", + " return sum(self.sample_blending_delay() + self.sample_desimenation_delay() for _ in range(self.blend_hops))\n", " \n", " def sample_broadcast_delay(self, blocks):\n", " return np.random.exponential(self.broadcast_delay_mean, size=blocks.shape)\n", @@ -67,14 +78,66 @@ " def block_arrival_slot(self, block_slot):\n", " if self.no_network_delay:\n", " return block_slot\n", - " return self.pol_proof_time + self.sample_mixnet_delay() + self.sample_broadcast_delay(block_slot) + block_slot\n", + " # return self.pol_proof_time + self.sample_mixnet_delay() + self.sample_broadcast_delay(block_slot) + block_slot\n", + " return self.pol_proof_time + self.sample_blend_network_delay() + self.sample_broadcast_delay(block_slot) + block_slot\n", "\n", - "\n" + " def empirical_network_delay(self, N=10000, M=1000):\n", + " return np.array([self.block_arrival_slot(np.zeros(M)) for _ in range(N)]).reshape(N*M)" ] }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 5, + "id": "17ef82f8-968c-48b0-bee7-f2642c8b3f3e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "blend_net = NetworkParams(\n", + " broadcast_delay_mean=0.5,\n", + " pol_proof_time=1,\n", + " blending_delay=3,\n", + " desimenation_delay_mean=0.5,\n", + " blend_hops=3,\n", + ")\n", + "no_blend_net = replace(blend_net, blend_hops=0)\n", + "\n", + "N = 100\n", + "M = 10000\n", + "no_blend_samples = no_blend_net.empirical_network_delay()\n", + "no_blend_mean = no_blend_samples.mean()\n", + "blend_samples = blend_net.empirical_network_delay()\n", + "blend_mean = blend_samples.mean()\n", + "\n", + "_ = plt.hist(no_blend_samples, bins=100, density=True, label=\"no-blend\")\n", + "_ = plt.hist(blend_samples, bins=100, density=True, label=\"blend\")\n", + "\n", + "for p in [50, 99, 99.9]:\n", + " no_blend_pct = np.percentile(no_blend_samples, p)\n", + " _ = plt.vlines(no_blend_pct, ymin=0, ymax=0.25, color='darkblue', label=f\"no-blend {p}p={no_blend_pct:.1f}s\")\n", + "\n", + "for p in [50, 99, 99.9]:\n", + " blend_pct = np.percentile(blend_samples, p)\n", + " _ = plt.vlines(blend_pct, ymin=0, ymax=0.25, color='brown', label=f\"blend {p}p={blend_pct:.1f}s\")\n", + "# _ = plt.vlines(blend_mean, ymin=0, ymax=1, color='brown', label=f\"blend 50p={blend_mean:.1f}s\")\n", + "# _ = plt.hist(blend_net.block_arrival_slot(np.zeros(1000)), bins=100, density=True, label=\"blend\")\n", + "_ = plt.legend()\n", + "_ = plt.xlabel(\"block delay\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, "id": "24779de7-284f-4200-9e4a-d2aa6e1b823b", "metadata": {}, "outputs": [], @@ -104,7 +167,7 @@ }, { "cell_type": "code", - "execution_count": 503, + "execution_count": 7, "id": "a90495a8-fcda-4e47-92b4-cc5ceaa9ff9c", "metadata": {}, "outputs": [], @@ -115,10 +178,14 @@ " self.network = network\n", " self.leaders = np.zeros((params.N, params.SLOTS), dtype=np.int64)\n", " self.blocks = []\n", - " self.block_slots = np.array([], dtype=np.int64)\n", - " self.block_heights = np.array([], dtype=np.int64)\n", - " self.block_arrivals = np.zeros(shape=(params.N, 0), dtype=np.int64) # arrival time to each leader for each block\n", + " max_number_of_blocks = int(3 * params.SLOTS * params.f)\n", + " self.block_slots = np.zeros(max_number_of_blocks, dtype=np.int64)\n", + " self.block_heights = np.zeros(max_number_of_blocks, dtype=np.int64)\n", + " self.block_arrivals = np.zeros(shape=(params.N, max_number_of_blocks), dtype=np.int64) # arrival time to each leader for each block\n", + " self.block_arrivals[:,:] = self.params.SLOTS\n", + " # self.block_arrivals = np.zeros(shape=(params.N, 0), dtype=np.int64) # arrival time to each leader for each block\n", "\n", + " \n", " def emit_block(self, leader, slot, height, parent):\n", " assert type(leader) in [int, np.int64]\n", " assert type(slot) in [int, np.int64]\n", @@ -133,8 +200,8 @@ " leader=leader,\n", " )\n", " self.blocks.append(block)\n", - " self.block_slots = np.append(self.block_slots, block.slot)\n", - " self.block_heights = np.append(self.block_heights, block.height)\n", + " self.block_slots[block.id] = block.slot\n", + " self.block_heights[block.id] = block.height\n", " \n", " # decide when this block will arrive at each node\n", " new_block_arrival_by_node = self.network.block_arrival_slot(np.repeat(block.slot, self.params.N))\n", @@ -143,8 +210,9 @@ " # the new block cannot arrive before it's parent\n", " parent_arrival_by_node = self.block_arrivals[:,parent]\n", " new_block_arrival_by_node = np.maximum(new_block_arrival_by_node, parent_arrival_by_node)\n", - " \n", - " self.block_arrivals = np.append(self.block_arrivals, new_block_arrival_by_node.reshape((self.params.N, 1)), axis=1)\n", + "\n", + " self.block_arrivals[:,block.id] = new_block_arrival_by_node\n", + " # self.block_arrivals = np.append(self.block_arrivals, new_block_arrival_by_node.reshape((self.params.N, 1)), axis=1)\n", "\n", " return block.id\n", "\n", @@ -163,13 +231,14 @@ " def fork_choice(self, leader, slot):\n", " assert type(leader) in [int, np.int64], type(leader)\n", " assert isinstance(slot, int)\n", - " arrived_blocks = self.block_arrivals[leader] <= slot\n", - " return (self.block_heights * arrived_blocks).argmax()\n", + " arrived_blocks = (self.block_arrivals[leader, :len(self.blocks)] <= slot) * self.block_heights[:len(self.blocks)]\n", + " concurrent = (arrived_blocks == np.max(arrived_blocks)).nonzero()[0]\n", + " return np.random.choice(concurrent)\n", "\n", " def plot_spacetime_diagram(self, MAX_SLOT=1000):\n", " alpha_index = sorted(range(self.params.N), key=lambda n: self.params.relative_stake[n])\n", " nodes = [f\"$N_{n}$($\\\\alpha$={self.params.relative_stake[n]:.2f})\" for n in alpha_index]\n", - " messages = [(nodes[alpha_index.index(self.blocks[b].leader)], nodes[alpha_index.index(node)], self.blocks[b].slot, arrival_slot, f\"$B_{{{b}}}$\") for b, arrival_slots in enumerate(self.block_arrivals.T) for node, arrival_slot in enumerate(arrival_slots) if arrival_slot < MAX_SLOT]\n", + " messages = [(nodes[alpha_index.index(self.blocks[b].leader)], nodes[alpha_index.index(node)], self.blocks[b].slot, arrival_slot, f\"$B_{{{b}}}$\") for b, arrival_slots in enumerate(self.block_arrivals[:,:len(self.blocks)].T) for node, arrival_slot in enumerate(arrival_slots) if arrival_slot < MAX_SLOT]\n", " \n", " fig, ax = plt.subplots(figsize=(8,4))\n", " \n", @@ -237,6 +306,9 @@ " return G.show(\"chain.html\")\n", "\n", " def run(self, seed=None):\n", + " from collections import defaultdict\n", + " timings = defaultdict(float)\n", + " start_t = time.time()\n", " if seed is not None:\n", " np.random.seed(seed)\n", "\n", @@ -247,60 +319,103 @@ " height=1,\n", " parent=-1,\n", " )\n", - " self.block_arrivals[:,:] = 0 # all nodes see the genesis block\n", - " \n", + " self.block_arrivals[:,0] = 0 # all nodes see the genesis block\n", + "\n", + " prep_t = time.time()\n", + "\n", + "\n", " for s in range(1, self.params.SLOTS):\n", + " slot_start_t = time.time()\n", " # the adversary will not participate in the simulation\n", " # (implemented by never delivering blocks to the adversary)\n", - " self.block_arrivals[-1,:] = self.params.SLOTS\n", + " # self.block_arrivals[-1,:] = self.params.SLOTS\n", "\n", " self.leaders[:,s] = np.random.random(size=self.params.N) < self.params.slot_prob()\n", + " leader_lottery_t = time.time()\n", "\n", " for leader in np.nonzero(self.leaders[:,s])[0]:\n", + " lead_start_t = time.time()\n", " if self.params.adversary_control is not None and leader == self.params.N - 1:\n", " continue\n", - " self.emit_leader_block(leader, s)\n", + " \n", + " parent = self.fork_choice(leader, s)\n", + " fork_choice_t = time.time()\n", + " \n", + " self.emit_block(\n", + " leader,\n", + " s,\n", + " height=self.blocks[parent].height + 1,\n", + " parent=parent,\n", + " )\n", + " emit_leader_block_t = time.time()\n", "\n", - " def adverserial_analysis(self, should_plot=True, seed=0):\n", + " timings[\"forkchoice\"] += fork_choice_t - lead_start_t\n", + " timings[\"emit_leader_block\"] += emit_leader_block_t - fork_choice_t\n", + " \n", + " # self.emit_leader_block(leader, s)\n", + " slot_end_t = time.time()\n", + " timings[\"leader\"] += leader_lottery_t - slot_start_t\n", + " timings[\"emit\"] += slot_end_t - leader_lottery_t\n", + " timings[\"slot\"] += slot_end_t - slot_start_t\n", + "\n", + " end_t = time.time()\n", + " timings[\"prep\"] = prep_t - start_t\n", + " timings[\"total\"] = end_t - start_t\n", + " for phase, duration in timings.items():\n", + " print(f\"{phase}\\t{duration:.2f}s\")\n", + "\n", + " def adverserial_analysis(self, should_plot=False, seed=0):\n", + " from collections import defaultdict\n", + "\n", + " timings = defaultdict(float)\n", + "\n", + " start_t = time.time()\n", " np.random.seed(seed)\n", - "\n", + " \n", " adversary = self.params.N-1 # adversary is always the last node in our simulations\n", "\n", - " self.block_arrivals[adversary,:] = self.block_slots # we will say the adversary receives the blocks immidiately\n", + " self.block_arrivals[adversary,:len(self.blocks)] = self.block_slots[:len(self.blocks)] # we will say the adversary receives the blocks immidiately\n", "\n", - " honest_height_by_slot = np.zeros(self.params.SLOTS, dtype=np.int64)\n", - " for block in self.blocks:\n", - " block_height = np.zeros(self.params.SLOTS, dtype=np.int64) + block.height\n", - " block_height[:block.slot] = 0\n", - " honest_height_by_slot = np.maximum(block_height, honest_height_by_slot)\n", - " \n", - " for slot in range(1, self.params.SLOTS):\n", - " if honest_height_by_slot[slot] == 0:\n", - " honest_height_by_slot[slot] = honest_height_by_slot[slot-1]\n", - "\n", - " \n", " honest_chain = self.honest_chain()\n", " \n", - " reorg_depths = np.array([], dtype=np.int64)\n", + " honest_chain_t = time.time()\n", + " \n", + " honest_height_by_slot = np.zeros(self.params.SLOTS, dtype=np.int64)\n", "\n", + " for block_id in honest_chain:\n", + " honest_height_by_slot[self.blocks[block_id].slot] = 1\n", + " honest_height_by_slot = honest_height_by_slot.cumsum()\n", + " \n", + " honest_height_by_slot_t = time.time()\n", + " \n", + " reorg_depths = []\n", " if should_plot:\n", " plt.figure(figsize=(20, 6))\n", " ax = plt.subplot(121)\n", " \n", " adversary_active_slots = np.random.random(size=self.params.SLOTS) < phi(self.params.f, self.params.relative_stake[adversary])\n", + " adversary_cumsum = adversary_active_slots.cumsum()\n", + "\n", " all_active_slots = (self.leaders.sum(axis=0) + adversary_active_slots) > 0\n", "\n", + " advantage = np.zeros(self.params.SLOTS)\n", + " prep_t = time.time()\n", + " timings[\"honest_chain\"] += honest_chain_t - start_t\n", + " timings[\"honest_height_by_slot\"] += honest_height_by_slot_t - honest_chain_t\n", + " timings[\"prep_analysis\"] += prep_t - start_t\n", " for b in range(len(self.blocks)):\n", - " if block.id > 0 and block.id % 1000 == 0:\n", - " print(\"Processing block\", block)\n", + " block_start_t = time.time()\n", " block = self.blocks[b]\n", + " if block.id > 0 and block.id % 5000 == 0:\n", + " print(\"Processing block\", block)\n", " \n", " nearest_honest_block = block\n", " while nearest_honest_block.height >= len(honest_chain) or honest_chain[nearest_honest_block.height-1] != nearest_honest_block.id:\n", " nearest_honest_block = self.blocks[nearest_honest_block.parent]\n", "\n", - " remaining_slots = adversary_active_slots[block.slot+1:]\n", - " cumulative_rel_height = remaining_slots.cumsum()\n", + " nearest_honest_t = time.time()\n", + " \n", + " cumulative_rel_height = adversary_cumsum[block.slot+1:] - adversary_cumsum[block.slot]\n", "\n", " adverserial_height_by_slot = block.height + cumulative_rel_height\n", "\n", @@ -309,22 +424,31 @@ " adverserial_wins = adverserial_height_by_slot > honest_height_by_slot_lookahead\n", " \n", " reorg_events = adverserial_wins & all_active_slots[block.slot+1:]\n", - " reorg_depths = np.append(reorg_depths, honest_height_by_slot_lookahead[reorg_events] - nearest_honest_block.height)\n", "\n", + " \n", + " reorg_events_t = time.time()\n", + " reorg_depth = honest_height_by_slot_lookahead[reorg_events] - nearest_honest_block.height\n", + " reorg_depth_t = time.time()\n", + " reorg_depths += list(reorg_depth)\n", + " block_end_t = time.time()\n", + " timings[\"nearest_honest\"] += nearest_honest_t - block_start_t\n", + " timings[\"reorg_events\"] += reorg_events_t - nearest_honest_t\n", + " timings[\"reorg_depth\"] += reorg_depth_t - reorg_events_t\n", + " timings[\"depth_append\"] += block_end_t - reorg_depth_t\n", + " \n", " if should_plot:\n", " if reorg_events.sum() > 0:\n", " first_slot = block.slot+1\n", " last_slot = first_slot + np.nonzero(reorg_events)[0].max() + 1\n", + " advantage[first_slot:last_slot] = np.maximum(advantage[first_slot:last_slot], adverserial_height_by_slot[:last_slot-first_slot]-honest_height_by_slot[first_slot:last_slot])\n", "\n", - " ax.plot(np.arange(first_slot, last_slot), adverserial_height_by_slot[:last_slot-first_slot]-honest_height_by_slot[first_slot:last_slot], lw=\"1\")\n", - " for event in np.nonzero(reorg_events)[0]:\n", - " plt.axvline(x = event + block.slot + 1, ymin = 0, ymax = 1, color ='red', lw=0.01)\n", - "\n", - " \n", + " for phase, duration in timings.items():\n", + " print(f\"{phase}\\t{duration:.2f}s\")\n", + " \n", " if should_plot:\n", - " ax.plot(np.zeros(self.params.SLOTS), color=\"k\", label=f\"honest chain\")\n", + " ax.plot(advantage, color='k', lw=\"0.5\")\n", " _ = ax.set_title(f\"max chain weight with adversery controlling {self.params.relative_stake[adversary] * 100:.0f}% of stake\")\n", - " _ = ax.set_ylabel(\"weight advantage\")\n", + " _ = ax.set_ylabel(\"adversary height advantage\")\n", " _ = ax.set_xlabel(\"slot\")\n", " _ = ax.legend()\n", "\n", @@ -339,75 +463,52 @@ }, { "cell_type": "code", - "execution_count": 124, - "id": "d7eef71a-aa3c-49df-a711-9c9f7f5cb4a8", - "metadata": {}, + "execution_count": 8, + "id": "a0123dab-cf0d-4721-81c7-bb881a27c13c", + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "avg blocks per slot 0.04708\n", - "Number of blocks 4708\n", - "longest chain 2345\n", - "CPU times: user 6.42 s, sys: 7.49 s, total: 13.9 s\n", - "Wall time: 14.7 s\n" + "cardano parameters\n", + "running sim\n", + "leader\t7.09s\n", + "emit\t1.11s\n", + "slot\t8.20s\n", + "forkchoice\t0.22s\n", + "emit_leader_block\t0.25s\n", + "prep\t0.00s\n", + "total\t8.27s\n", + "finished sim in 8.27s\n", + "running analysis\n", + "Processing block Block(id=5000, slot=142066, height=4877, parent=np.int64(4999), leader=np.int64(38))\n", + "Processing block Block(id=10000, slot=280035, height=9754, parent=np.int64(9999), leader=np.int64(60))\n", + "honest_chain\t0.00s\n", + "honest_height_by_slot\t0.00s\n", + "prep_analysis\t0.14s\n", + "nearest_honest\t0.00s\n", + "reorg_events\t2.57s\n", + "reorg_depth\t0.17s\n", + "depth_append\t0.01s\n", + "finished analysis in 3.64s\n", + "CPU times: user 10.8 s, sys: 1.1 s, total: 11.9 s\n", + "Wall time: 11.9 s\n" ] - } - ], - "source": [ - "%%time\n", - "np.random.seed(0)\n", - "sim = Sim(\n", - " params=Params(\n", - " SLOTS=100000,\n", - " f=0.05,\n", - " adversary_control = 0.1,\n", - " honest_stake = np.random.pareto(10, 1000)\n", - " ),\n", - " network=NetworkParams(\n", - " mixnet_delay_mean=10, # seconds\n", - " mixnet_delay_var=4,\n", - " broadcast_delay_mean=2, # second\n", - " pol_proof_time=10, # seconds\n", - " no_network_delay=False\n", - " )\n", - ")\n", - "sim.run(seed=5)\n", - "\n", - "n_blocks_per_slot = len(sim.blocks) / sim.params.SLOTS\n", - "print(\"avg blocks per slot\", n_blocks_per_slot)\n", - "print(\"Number of blocks\", len(sim.blocks))\n", - "print(\"longest chain\", max(b.height for b in sim.blocks))" - ] - }, - { - "cell_type": "code", - "execution_count": 125, - "id": "aabccc4e-8f47-403e-b7f9-7508e93ec18b", - "metadata": {}, - "outputs": [], - "source": [ - "#sim.visualize_chain()" - ] - }, - { - "cell_type": "code", - "execution_count": 126, - "id": "0b5b4d8d-85af-4252-b12a-f27fef099d29", - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "CPU times: user 2.95 s, sys: 287 ms, total: 3.24 s\n", - "Wall time: 3.28 s\n" + "/tmp/ipykernel_40560/682093512.py:279: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " _ = ax.legend()\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -418,50 +519,138 @@ ], "source": [ "%%time\n", - "reorgs = sim.adverserial_analysis()" + "print(\"cardano parameters\")\n", + "target_block_number = 20000\n", + "cardano_block_time = 20\n", + "cardano_sim = Sim(\n", + " params=Params(\n", + " SLOTS=int(target_block_number * cardano_block_time),\n", + " f=1/cardano_block_time,\n", + " adversary_control = 0.30,\n", + " honest_stake = np.random.pareto(10, 1000)\n", + " ),\n", + " network=no_blend_net\n", + ")\n", + "start_t = time.time()\n", + "print(\"running sim\")\n", + "cardano_sim.run(seed=5)\n", + "sim_t = time.time()\n", + "print(f\"finished sim in {sim_t - start_t:.2f}s\")\n", + "print(\"running analysis\")\n", + "cardano_adv = cardano_sim.adverserial_analysis(should_plot=True)\n", + "print(f\"finished analysis in {time.time() - sim_t:.2f}s\")" ] }, { "cell_type": "code", - "execution_count": 127, - "id": "78567508-a1a3-4b89-abd3-9cd1b4bbb692", + "execution_count": 9, + "id": "a9c8b16c-e813-441a-a123-f0a6253d9ef5", + "metadata": {}, + "outputs": [], + "source": [ + "# cardano_sim.visualize_chain()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "5f2da916-30a0-4b1d-886f-1bc81c17056e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2.08% of slots were reorged with depth >= 0\n", - "1.41% of slots were reorged with depth >= 1\n", - "0.68% of slots were reorged with depth >= 2\n", - "0.29% of slots were reorged with depth >= 3\n", - "0.13% of slots were reorged with depth >= 4\n", - "0.06% of slots were reorged with depth >= 5\n", - "0.03% of slots were reorged with depth >= 6\n", - "0.01% of slots were reorged with depth >= 7\n", - "0.00% of slots were reorged with depth >= 8\n", - "0.00% of slots were reorged with depth >= 9\n", - "0.00% of slots were reorged with depth >= 10\n", - "0.00% of slots were reorged with depth >= 11\n", - "0.00% of slots were reorged with depth >= 12\n", - "0.00% of slots were reorged with depth >= 13\n", - "0.00% of slots were reorged with depth >= 14\n", - "0.00% of slots were reorged with depth >= 15\n", - "0.00% of slots were reorged with depth >= 16\n", - "0.00% of slots were reorged with depth >= 17\n", - "0.00% of slots were reorged with depth >= 18\n", - "0.00% of slots were reorged with depth >= 19\n" + "leader\t0.02s\n", + "emit\t0.01s\n", + "slot\t0.03s\n", + "forkchoice\t0.00s\n", + "emit_leader_block\t0.00s\n", + "prep\t0.00s\n", + "total\t0.03s\n", + "avg blocks per slot 0.168\n", + "Number of blocks 168\n", + "longest chain 95\n", + "CPU times: user 27.2 ms, sys: 1.67 ms, total: 28.9 ms\n", + "Wall time: 28.2 ms\n" ] } ], "source": [ - "for DEPTH in range(20):\n", - " print(f\"{len(reorgs[reorgs >= DEPTH]) / sim.params.SLOTS*100:.2f}% of slots were reorged with depth >= {DEPTH}\")" + "%%time\n", + "np.random.seed(0)\n", + "sim = Sim(\n", + " params=Params(\n", + " SLOTS=1000,\n", + " f=1/5,\n", + " adversary_control = 0.3,\n", + " honest_stake = np.random.pareto(10, 1000)\n", + " ),\n", + " network=blend_net\n", + ")\n", + "sim.run(seed=0)\n", + "\n", + "n_blocks_per_slot = len(sim.blocks) / sim.params.SLOTS\n", + "print(\"avg blocks per slot\", n_blocks_per_slot)\n", + "print(\"Number of blocks\", len(sim.blocks))\n", + "print(\"longest chain\", max(b.height for b in sim.blocks))" ] }, { "cell_type": "code", - "execution_count": 128, + "execution_count": 11, + "id": "3130e27c-1ce6-439a-a6e7-436990b9315d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "honest_chain\t0.00s\n", + "honest_height_by_slot\t0.00s\n", + "prep_analysis\t0.00s\n", + "nearest_honest\t0.00s\n", + "reorg_events\t0.00s\n", + "reorg_depth\t0.00s\n", + "depth_append\t0.00s\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_40560/682093512.py:279: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " _ = ax.legend()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "_ = sim.adverserial_analysis(should_plot=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "13b4392d-d4ab-4b97-a7db-2bede9b3de9a", + "metadata": {}, + "outputs": [], + "source": [ + "# sim.visualize_chain()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, "id": "76de5a72-cca5-4b00-9feb-7563cca9c03d", "metadata": {}, "outputs": [ @@ -469,39 +658,57 @@ "name": "stdout", "output_type": "stream", "text": [ - "simulating 1/10\n", - "simulating 2/10\n", - "simulating 3/10\n", - "simulating 4/10\n", - "simulating 5/10\n", - "simulating 6/10\n", - "simulating 7/10\n", - "simulating 8/10\n", - "simulating 9/10\n", - "simulating 10/10\n", - "finished simulation, starting analysis\n" + "simulating 1/2\n", + "leader\t0.85s\n", + "emit\t0.23s\n", + "slot\t1.07s\n", + "forkchoice\t0.06s\n", + "emit_leader_block\t0.06s\n", + "prep\t0.00s\n", + "total\t1.09s\n", + "simulating 2/2\n", + "leader\t0.83s\n", + "emit\t0.18s\n", + "slot\t1.01s\n", + "forkchoice\t0.04s\n", + "emit_leader_block\t0.04s\n", + "prep\t0.00s\n", + "total\t1.03s\n", + "finished simulation, starting analysis\n", + "Processing block Block(id=5000, slot=98845, height=3776, parent=np.int64(4999), leader=np.int64(18))\n", + "honest_chain\t0.00s\n", + "honest_height_by_slot\t0.00s\n", + "prep_analysis\t0.00s\n", + "nearest_honest\t0.00s\n", + "reorg_events\t0.15s\n", + "reorg_depth\t0.01s\n", + "depth_append\t0.00s\n", + "honest_chain\t0.00s\n", + "honest_height_by_slot\t0.00s\n", + "prep_analysis\t0.00s\n", + "nearest_honest\t0.00s\n", + "reorg_events\t0.10s\n", + "reorg_depth\t0.01s\n", + "depth_append\t0.00s\n", + "CPU times: user 2.36 s, sys: 75.7 ms, total: 2.44 s\n", + "Wall time: 2.43 s\n" ] } ], "source": [ + "%%time\n", "np.random.seed(0)\n", "stake = np.random.pareto(10, 100)\n", "\n", "sims = [Sim(\n", " params=Params(\n", - " SLOTS=10000,\n", + " SLOTS=100000,\n", " f=0.05,\n", " adversary_control = i,\n", " honest_stake = stake\n", " ),\n", - " network=NetworkParams(\n", - " mixnet_delay_mean=10, # seconds\n", - " mixnet_delay_var=4,\n", - " broadcast_delay_mean=2, # second\n", - " pol_proof_time=10, # seconds\n", - " no_network_delay=False\n", - " )\n", - ") for i in np.linspace(1e-3, 0.3, 10)]\n", + " network=blend_net\n", + ") for i in np.linspace(1e-3, 0.3, 2)]\n", "\n", "for i, sim in enumerate(sims):\n", " print(f\"simulating {i+1}/{len(sims)}\")\n", @@ -513,13 +720,13 @@ }, { "cell_type": "code", - "execution_count": 129, + "execution_count": 14, "id": "52ff4e83-c6f9-4933-9190-564124a479bc", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -529,14 +736,14 @@ } ], "source": [ - "max_reorg_depth = max(a.max() if len(a) > 0 else 0 for a in advs)\n", + "max_reorg_depth = max(max(a) if len(a) > 0 else 0 for a in advs)\n", "\n", "\n", "heatmap = np.zeros((len(advs), max_reorg_depth), dtype=np.int64)\n", "\n", "for i, adv in enumerate(advs):\n", " for depth in range(max_reorg_depth):\n", - " heatmap[i][depth] = (adv == depth).sum()\n", + " heatmap[i][depth] = (np.array(adv) == depth).sum()\n", "\n", "plt.figure(figsize=(40,40))\n", "ax = plt.subplot(121)\n", @@ -555,9 +762,41 @@ "_ = ax.set_ylabel(\"frequency\")" ] }, + { + "cell_type": "markdown", + "id": "1f552a04-a9bf-4723-b6a8-8faaa147762e", + "metadata": {}, + "source": [ + "# Reorg sensitivity to blending delay" + ] + }, { "cell_type": "code", - "execution_count": 542, + "execution_count": 15, + "id": "f2bbb618-96c0-4a6d-b1dc-3b73ebafa5e2", + "metadata": {}, + "outputs": [], + "source": [ + "def reorg_depth_analysis(sim, adv, MAX, **kwargs):\n", + " max_depth = min(MAX, max(adv) if sum(adv) > 0 else 0)\n", + " \n", + " count_by_depth = np.bincount(adv, minlength=max_depth)[:max_depth]\n", + " \n", + " # count_by_depth = np.zeros(max_depth)\n", + " \n", + " # for d in range(max_depth):\n", + " # count_by_depth[d] = (adv == d).sum()\n", + "\n", + " block_time = 1 / sim.params.f\n", + " honest_chain_length = len(sim.honest_chain())\n", + " blocks = len(sim.blocks)\n", + " expected_blocks = sim.params.SLOTS * sim.params.f\n", + " plt.plot(np.arange(max_depth), count_by_depth / expected_blocks, **kwargs)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, "id": "9cca2f57-1083-446c-b083-1dd158e0e7ca", "metadata": {}, "outputs": [ @@ -565,79 +804,87 @@ "name": "stdout", "output_type": "stream", "text": [ - "simulating 1/5\n", - "simulating 2/5\n", - "simulating 3/5\n", - "simulating 4/5\n", - "simulating 5/5\n", + "simulating 1/4\n", + "leader\t1.83s\n", + "emit\t0.25s\n", + "slot\t2.08s\n", + "forkchoice\t0.02s\n", + "emit_leader_block\t0.05s\n", + "prep\t0.00s\n", + "total\t2.10s\n", + "simulating 2/4\n", + "leader\t1.82s\n", + "emit\t0.25s\n", + "slot\t2.07s\n", + "forkchoice\t0.03s\n", + "emit_leader_block\t0.05s\n", + "prep\t0.00s\n", + "total\t2.09s\n", + "simulating 3/4\n", + "leader\t1.89s\n", + "emit\t0.30s\n", + "slot\t2.19s\n", + "forkchoice\t0.03s\n", + "emit_leader_block\t0.09s\n", + "prep\t0.00s\n", + "total\t2.21s\n", + "simulating 4/4\n", + "leader\t1.82s\n", + "emit\t0.25s\n", + "slot\t2.07s\n", + "forkchoice\t0.03s\n", + "emit_leader_block\t0.05s\n", + "prep\t0.00s\n", + "total\t2.09s\n", "finished simulation, starting analysis\n", - "Processing block Block(id=1000, slot=21002, height=953, parent=999, leader=20)\n", - "Processing block Block(id=2000, slot=43475, height=1911, parent=1999, leader=72)\n", - "Processing block Block(id=3000, slot=64765, height=2867, parent=2999, leader=23)\n", - "Processing block Block(id=4000, slot=86142, height=3833, parent=3999, leader=70)\n", - "Processing block Block(id=5000, slot=107452, height=4794, parent=4999, leader=52)\n", - "Processing block Block(id=6000, slot=129648, height=5760, parent=5999, leader=41)\n", - "Processing block Block(id=7000, slot=150919, height=6702, parent=6999, leader=70)\n", - "Processing block Block(id=8000, slot=172689, height=7650, parent=7999, leader=66)\n", - "Processing block Block(id=9000, slot=194671, height=8614, parent=8999, leader=27)\n", - "Processing block Block(id=1000, slot=21002, height=724, parent=999, leader=20)\n", - "Processing block Block(id=2000, slot=43475, height=1451, parent=1997, leader=72)\n", - "Processing block Block(id=3000, slot=64765, height=2150, parent=2999, leader=23)\n", - "Processing block Block(id=4000, slot=86142, height=2886, parent=3999, leader=70)\n", - "Processing block Block(id=5000, slot=107452, height=3612, parent=4997, leader=52)\n", - "Processing block Block(id=6000, slot=129648, height=4345, parent=5998, leader=41)\n", - "Processing block Block(id=7000, slot=150919, height=5067, parent=6998, leader=70)\n", - "Processing block Block(id=8000, slot=172689, height=5777, parent=7998, leader=66)\n", - "Processing block Block(id=9000, slot=194671, height=6507, parent=8999, leader=27)\n", - "Processing block Block(id=1000, slot=21002, height=584, parent=999, leader=20)\n", - "Processing block Block(id=2000, slot=43475, height=1157, parent=1997, leader=72)\n", - "Processing block Block(id=3000, slot=64765, height=1733, parent=2998, leader=23)\n", - "Processing block Block(id=4000, slot=86142, height=2329, parent=3999, leader=70)\n", - "Processing block Block(id=5000, slot=107452, height=2912, parent=4997, leader=52)\n", - "Processing block Block(id=6000, slot=129648, height=3510, parent=5998, leader=41)\n", - "Processing block Block(id=7000, slot=150919, height=4102, parent=6995, leader=70)\n", - "Processing block Block(id=8000, slot=172689, height=4684, parent=7996, leader=66)\n", - "Processing block Block(id=9000, slot=194671, height=5264, parent=8998, leader=27)\n", - "Processing block Block(id=1000, slot=21002, height=476, parent=999, leader=20)\n", - "Processing block Block(id=2000, slot=43475, height=953, parent=1996, leader=72)\n", - "Processing block Block(id=3000, slot=64765, height=1429, parent=2998, leader=23)\n", - "Processing block Block(id=4000, slot=86142, height=1936, parent=3996, leader=70)\n", - "Processing block Block(id=5000, slot=107452, height=2429, parent=4998, leader=52)\n", - "Processing block Block(id=6000, slot=129648, height=2928, parent=5998, leader=41)\n", - "Processing block Block(id=7000, slot=150919, height=3419, parent=6996, leader=70)\n", - "Processing block Block(id=8000, slot=172689, height=3905, parent=7996, leader=66)\n", - "Processing block Block(id=9000, slot=194671, height=4406, parent=8998, leader=27)\n", - "Processing block Block(id=1000, slot=21002, height=421, parent=999, leader=20)\n", - "Processing block Block(id=2000, slot=43475, height=838, parent=1997, leader=72)\n", - "Processing block Block(id=3000, slot=64765, height=1254, parent=2998, leader=23)\n", - "Processing block Block(id=4000, slot=86142, height=1676, parent=3996, leader=70)\n", - "Processing block Block(id=5000, slot=107452, height=2098, parent=4998, leader=52)\n", - "Processing block Block(id=6000, slot=129648, height=2537, parent=5998, leader=41)\n", - "Processing block Block(id=7000, slot=150919, height=2950, parent=6992, leader=70)\n", - "Processing block Block(id=8000, slot=172689, height=3378, parent=7996, leader=66)\n", - "Processing block Block(id=9000, slot=194671, height=3810, parent=8996, leader=27)\n" + "honest_chain\t0.00s\n", + "honest_height_by_slot\t0.00s\n", + "prep_analysis\t0.04s\n", + "nearest_honest\t0.00s\n", + "reorg_events\t0.06s\n", + "reorg_depth\t0.01s\n", + "depth_append\t0.00s\n", + "honest_chain\t0.00s\n", + "honest_height_by_slot\t0.00s\n", + "prep_analysis\t0.05s\n", + "nearest_honest\t0.00s\n", + "reorg_events\t0.07s\n", + "reorg_depth\t0.01s\n", + "depth_append\t0.00s\n", + "honest_chain\t0.00s\n", + "honest_height_by_slot\t0.00s\n", + "prep_analysis\t0.04s\n", + "nearest_honest\t0.00s\n", + "reorg_events\t0.06s\n", + "reorg_depth\t0.01s\n", + "depth_append\t0.00s\n", + "honest_chain\t0.00s\n", + "honest_height_by_slot\t0.00s\n", + "prep_analysis\t0.05s\n", + "nearest_honest\t0.00s\n", + "reorg_events\t0.07s\n", + "reorg_depth\t0.01s\n", + "depth_append\t0.00s\n", + "CPU times: user 8.71 s, sys: 273 ms, total: 8.99 s\n", + "Wall time: 9 s\n" ] } ], "source": [ + "%%time\n", + "\n", "np.random.seed(0)\n", - "stake = np.random.pareto(10, 100)\n", + "stake = np.random.pareto(10, 1000)\n", "\n", "sims = [Sim(\n", " params=Params(\n", - " SLOTS=200000,\n", - " f=0.05,\n", - " adversary_control = 0.1,\n", + " SLOTS=100000,\n", + " f=1/30,\n", + " adversary_control = 0.3,\n", " honest_stake = stake\n", " ),\n", - " network=NetworkParams(\n", - " mixnet_delay_mean=i, # seconds\n", - " mixnet_delay_var=(i / 5)**2,\n", - " broadcast_delay_mean=1e-6, # second\n", - " pol_proof_time=0, # seconds\n", - " no_network_delay=False\n", - " )\n", - ") for i in np.linspace(1, 30, 5)]\n", + " network=replace(blend_net, blending_delay=i),\n", + ") for i in [1,3,5,10]]\n", "\n", "\n", "for i, sim in enumerate(sims):\n", @@ -650,13 +897,13 @@ }, { "cell_type": "code", - "execution_count": 543, + "execution_count": 17, "id": "1ff938f3-6bc4-4b8e-bd9a-492db140d7b9", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -666,26 +913,24 @@ } ], "source": [ - "for s in range(len(sims)):\n", - " max_depth = advs[s].max()\n", - " count_by_depth = np.zeros(max_depth)\n", - " for d in range(max_depth):\n", - " count_by_depth[d] = (advs[s] == d).sum() / (sims[s].params.SLOTS * sims[s].params.f)\n", - " plt.plot(np.arange(max_depth), count_by_depth, label=f\"E[mixnet_delay]={sims[s].network.mixnet_delay_mean:.1f}s\")\n", + "MAX=min(40, max(max(adv) for adv in advs))\n", "\n", - "_ = plt.title(f\"reorg depth sensitivity to mixnet delay @ {1/sims[s].params.f:.0f}s block time\")\n", + "for s in range(len(sims)):\n", + " reorg_depth_analysis(sims[s], advs[s], MAX, label=f\"blending_delay={sims[s].network.blending_delay}s\")\n", + "\n", + "_ = plt.title(f\"reorg depth sensitivity to blend network delay @ {1/sims[s].params.f:.0f}s block time\")\n", "_ = plt.xlabel(\"reorg depth\")\n", "_ = plt.ylabel(\"frequency\")\n", "_ = plt.legend()\n", "_ = plt.yscale(\"log\")\n", - "_ = plt.xlim(0, 25)\n", - "_ = plt.ylim(10**-3,10**0)\n", + "_ = plt.xlim(0, MAX)\n", + "_ = plt.ylim(10**-4,None)\n", "# _ = plt." ] }, { "cell_type": "code", - "execution_count": 492, + "execution_count": null, "id": "8c9a369c-2d55-4c07-8bfe-9e270cfed90a", "metadata": {}, "outputs": [ @@ -693,239 +938,228 @@ "name": "stdout", "output_type": "stream", "text": [ - "simulating 1/4\n", - "simulating 2/4\n", - "simulating 3/4\n", - "simulating 4/4\n", + "simulating 1/5\n", + "leader\t11.23s\n", + "emit\t1.81s\n", + "slot\t13.04s\n", + "forkchoice\t0.34s\n", + "emit_leader_block\t0.44s\n", + "prep\t0.00s\n", + "total\t13.16s\n", + "simulating 2/5\n", + "leader\t11.14s\n", + "emit\t1.82s\n", + "slot\t12.96s\n", + "forkchoice\t0.36s\n", + "emit_leader_block\t0.45s\n", + "prep\t0.00s\n", + "total\t13.07s\n", + "simulating 3/5\n", + "leader\t11.21s\n", + "emit\t1.79s\n", + "slot\t13.00s\n", + "forkchoice\t0.34s\n", + "emit_leader_block\t0.43s\n", + "prep\t0.00s\n", + "total\t13.12s\n", + "simulating 4/5\n", + "leader\t11.37s\n", + "emit\t1.97s\n", + "slot\t13.34s\n", + "forkchoice\t0.38s\n", + "emit_leader_block\t0.55s\n", + "prep\t0.00s\n", + "total\t13.46s\n", + "simulating 5/5\n", + "leader\t11.49s\n", + "emit\t1.98s\n", + "slot\t13.47s\n", + "forkchoice\t0.41s\n", + "emit_leader_block\t0.53s\n", + "prep\t0.00s\n", + "total\t13.59s\n", "finished simulation, starting analysis\n", - "Processing block Block(id=1000, slot=6363, height=320, parent=996, leader=23)\n", - "Processing block Block(id=2000, slot=12555, height=639, parent=1993, leader=84)\n", - "Processing block Block(id=3000, slot=18477, height=952, parent=2996, leader=17)\n", - "Processing block Block(id=4000, slot=25149, height=1282, parent=3996, leader=20)\n", - "Processing block Block(id=5000, slot=31501, height=1599, parent=4998, leader=56)\n", - "Processing block Block(id=6000, slot=37990, height=1919, parent=5991, leader=8)\n", - "Processing block Block(id=7000, slot=44481, height=2251, parent=6997, leader=27)\n", - "Processing block Block(id=8000, slot=50868, height=2578, parent=7992, leader=36)\n", - "Processing block Block(id=9000, slot=57212, height=2896, parent=8996, leader=8)\n", - "Processing block Block(id=10000, slot=63774, height=3230, parent=9996, leader=52)\n", - "Processing block Block(id=11000, slot=70157, height=3546, parent=10993, leader=0)\n", - "Processing block Block(id=12000, slot=76603, height=3862, parent=11988, leader=23)\n", - "Processing block Block(id=13000, slot=82834, height=4181, parent=12995, leader=85)\n", - "Processing block Block(id=14000, slot=89666, height=4523, parent=13994, leader=62)\n", - "Processing block Block(id=15000, slot=95882, height=4848, parent=14996, leader=7)\n", - "Processing block Block(id=16000, slot=102488, height=5177, parent=15997, leader=8)\n", - "Processing block Block(id=17000, slot=108773, height=5491, parent=16995, leader=5)\n", - "Processing block Block(id=18000, slot=115521, height=5820, parent=17993, leader=89)\n", - "Processing block Block(id=19000, slot=121882, height=6133, parent=18994, leader=68)\n", - "Processing block Block(id=20000, slot=128075, height=6448, parent=19990, leader=35)\n", - "Processing block Block(id=21000, slot=134265, height=6774, parent=20996, leader=10)\n", - "Processing block Block(id=22000, slot=140656, height=7092, parent=21995, leader=98)\n", - "Processing block Block(id=23000, slot=146896, height=7405, parent=22997, leader=50)\n", - "Processing block Block(id=1000, slot=13599, height=507, parent=995, leader=38)\n", - "Processing block Block(id=2000, slot=27183, height=999, parent=1999, leader=85)\n", - "Processing block Block(id=3000, slot=40799, height=1491, parent=2995, leader=45)\n", - "Processing block Block(id=4000, slot=53827, height=1978, parent=3995, leader=20)\n", - "Processing block Block(id=5000, slot=66897, height=2473, parent=4994, leader=6)\n", - "Processing block Block(id=6000, slot=80538, height=2985, parent=5999, leader=19)\n", - "Processing block Block(id=7000, slot=94047, height=3485, parent=6996, leader=73)\n", - "Processing block Block(id=8000, slot=107291, height=3990, parent=7999, leader=10)\n", - "Processing block Block(id=9000, slot=120394, height=4502, parent=8998, leader=52)\n", - "Processing block Block(id=10000, slot=134175, height=5014, parent=9999, leader=70)\n", - "Processing block Block(id=11000, slot=147463, height=5517, parent=10997, leader=73)\n", - "Processing block Block(id=12000, slot=160780, height=6014, parent=11998, leader=21)\n", - "Processing block Block(id=13000, slot=174393, height=6517, parent=12999, leader=49)\n", - "Processing block Block(id=14000, slot=187294, height=6991, parent=13999, leader=17)\n", - "Processing block Block(id=15000, slot=201132, height=7503, parent=14999, leader=37)\n", - "Processing block Block(id=16000, slot=214289, height=7998, parent=15997, leader=23)\n", - "Processing block Block(id=17000, slot=227195, height=8491, parent=16999, leader=38)\n", - "Processing block Block(id=18000, slot=240271, height=8990, parent=17997, leader=13)\n", - "Processing block Block(id=19000, slot=254358, height=9507, parent=18998, leader=70)\n", - "Processing block Block(id=20000, slot=267926, height=10010, parent=19996, leader=19)\n", - "Processing block Block(id=21000, slot=281002, height=10497, parent=20999, leader=20)\n", - "Processing block Block(id=22000, slot=294406, height=10999, parent=21999, leader=32)\n", - "Processing block Block(id=1000, slot=27987, height=680, parent=999, leader=42)\n", - "Processing block Block(id=2000, slot=54664, height=1341, parent=1999, leader=8)\n", - "Processing block Block(id=3000, slot=81950, height=2006, parent=2999, leader=38)\n", - "Processing block Block(id=4000, slot=108979, height=2670, parent=3995, leader=38)\n", - "Processing block Block(id=5000, slot=136878, height=3343, parent=4999, leader=40)\n", - "Processing block Block(id=6000, slot=163748, height=4015, parent=5998, leader=70)\n", - "Processing block Block(id=7000, slot=192675, height=4698, parent=6999, leader=68)\n", - "Processing block Block(id=8000, slot=221466, height=5369, parent=7999, leader=1)\n", - "Processing block Block(id=9000, slot=248970, height=6030, parent=8999, leader=93)\n", - "Processing block Block(id=10000, slot=277928, height=6714, parent=9998, leader=66)\n", - "Processing block Block(id=11000, slot=305384, height=7372, parent=10999, leader=42)\n", - "Processing block Block(id=12000, slot=332509, height=8051, parent=11997, leader=92)\n", - "Processing block Block(id=13000, slot=359097, height=8708, parent=12998, leader=19)\n", - "Processing block Block(id=14000, slot=387363, height=9366, parent=13997, leader=33)\n", - "Processing block Block(id=15000, slot=414827, height=10023, parent=14995, leader=17)\n", - "Processing block Block(id=16000, slot=442300, height=10693, parent=15999, leader=89)\n", - "Processing block Block(id=17000, slot=470243, height=11365, parent=16999, leader=8)\n", - "Processing block Block(id=18000, slot=499093, height=12056, parent=17998, leader=83)\n", - "Processing block Block(id=19000, slot=526688, height=12721, parent=18999, leader=89)\n", - "Processing block Block(id=20000, slot=555973, height=13410, parent=19998, leader=38)\n", - "Processing block Block(id=21000, slot=583015, height=14057, parent=20998, leader=70)\n", - "Processing block Block(id=1000, slot=42927, height=756, parent=999, leader=21)\n", - "Processing block Block(id=2000, slot=84798, height=1524, parent=1999, leader=21)\n", - "Processing block Block(id=3000, slot=126990, height=2279, parent=2999, leader=35)\n", - "Processing block Block(id=4000, slot=168468, height=3022, parent=3999, leader=86)\n", - "Processing block Block(id=5000, slot=211518, height=3781, parent=4998, leader=13)\n", - "Processing block Block(id=6000, slot=254462, height=4515, parent=5999, leader=7)\n", - "Processing block Block(id=7000, slot=297291, height=5284, parent=6997, leader=30)\n", - "Processing block Block(id=8000, slot=337460, height=6021, parent=7999, leader=68)\n", - "Processing block Block(id=9000, slot=379964, height=6780, parent=8999, leader=4)\n", - "Processing block Block(id=10000, slot=421773, height=7525, parent=9997, leader=74)\n", - "Processing block Block(id=11000, slot=463452, height=8279, parent=10999, leader=2)\n", - "Processing block Block(id=12000, slot=508227, height=9044, parent=11999, leader=42)\n", - "Processing block Block(id=13000, slot=551336, height=9812, parent=12998, leader=4)\n", - "Processing block Block(id=14000, slot=593129, height=10575, parent=13997, leader=70)\n", - "Processing block Block(id=15000, slot=633453, height=11328, parent=14999, leader=13)\n", - "Processing block Block(id=16000, slot=674863, height=12062, parent=15999, leader=38)\n", - "Processing block Block(id=17000, slot=714726, height=12815, parent=16999, leader=68)\n", - "Processing block Block(id=18000, slot=757976, height=13567, parent=17998, leader=45)\n", - "Processing block Block(id=19000, slot=799790, height=14311, parent=18998, leader=17)\n", - "Processing block Block(id=20000, slot=841233, height=15063, parent=19997, leader=52)\n", - "Processing block Block(id=21000, slot=881361, height=15808, parent=20998, leader=89)\n" + "Processing block Block(id=5000, slot=166060, height=4172, parent=np.int64(4999), leader=np.int64(898))\n", + "Processing block Block(id=10000, slot=328970, height=8300, parent=np.int64(9998), leader=np.int64(368))\n", + "Processing block Block(id=15000, slot=492430, height=12468, parent=np.int64(14999), leader=np.int64(458))\n", + "honest_chain\t0.00s\n", + "honest_height_by_slot\t0.00s\n", + "prep_analysis\t0.20s\n", + "nearest_honest\t0.01s\n", + "reorg_events\t6.10s\n", + "reorg_depth\t0.22s\n", + "depth_append\t0.01s\n", + "Processing block Block(id=5000, slot=163604, height=4167, parent=np.int64(4999), leader=np.int64(688))\n", + "Processing block Block(id=10000, slot=327820, height=8322, parent=np.int64(9998), leader=np.int64(851))\n", + "Processing block Block(id=15000, slot=491848, height=12478, parent=np.int64(14998), leader=np.int64(698))\n", + "honest_chain\t0.00s\n", + "honest_height_by_slot\t0.00s\n", + "prep_analysis\t0.85s\n", + "nearest_honest\t0.01s\n", + "reorg_events\t6.49s\n", + "reorg_depth\t0.23s\n", + "depth_append\t0.01s\n", + "Processing block Block(id=5000, slot=167054, height=4189, parent=np.int64(4998), leader=np.int64(298))\n", + "Processing block Block(id=10000, slot=331876, height=8365, parent=np.int64(9999), leader=np.int64(74))\n", + "Processing block Block(id=15000, slot=495548, height=12498, parent=np.int64(14998), leader=np.int64(751))\n", + "honest_chain\t0.00s\n", + "honest_height_by_slot\t0.00s\n", + "prep_analysis\t0.74s\n", + "nearest_honest\t0.01s\n", + "reorg_events\t5.64s\n", + "reorg_depth\t0.22s\n", + "depth_append\t0.01s\n", + "Processing block Block(id=5000, slot=163948, height=4205, parent=np.int64(4999), leader=np.int64(263))\n", + "Processing block Block(id=10000, slot=330307, height=8387, parent=np.int64(9999), leader=np.int64(430))\n", + "Processing block Block(id=15000, slot=490093, height=12555, parent=np.int64(14999), leader=np.int64(579))\n", + "honest_chain\t0.00s\n", + "honest_height_by_slot\t0.00s\n", + "prep_analysis\t0.78s\n", + "nearest_honest\t0.01s\n", + "reorg_events\t5.49s\n", + "reorg_depth\t0.22s\n", + "depth_append\t0.01s\n", + "Processing block Block(id=5000, slot=159701, height=4168, parent=np.int64(4999), leader=np.int64(726))\n", + "Processing block Block(id=10000, slot=322826, height=8390, parent=np.int64(9999), leader=np.int64(487))\n", + "Processing block Block(id=15000, slot=486552, height=12577, parent=np.int64(14999), leader=np.int64(437))\n", + "honest_chain\t0.00s\n", + "honest_height_by_slot\t0.00s\n", + "prep_analysis\t0.58s\n", + "nearest_honest\t0.01s\n", + "reorg_events\t5.48s\n", + "reorg_depth\t0.22s\n", + "depth_append\t0.01s\n", + "cardano parameters\n", + "simulating 1/5\n" ] } ], "source": [ + "%%time\n", + "PATHS = 5\n", + "target_block_num = 20000\n", "np.random.seed(0)\n", - "stake = np.random.pareto(10, 100)\n", - "\n", - "mixnet_delay_mean = 10\n", - "\n", + "stake = np.random.pareto(10, 1000)\n", + "network = blend_net\n", + "sim_params = Params(\n", + " SLOTS=0,\n", + " f=0.05,\n", + " adversary_control = 0.10,\n", + " honest_stake = stake\n", + ")\n", + "np.random.seed(1)\n", "sims = [Sim(\n", - " params=Params(\n", - " SLOTS=int(30000 * 1 / (1/mixnet_delay_mean / i)),\n", - " f=1/mixnet_delay_mean / i,\n", - " adversary_control = 0.3,\n", - " honest_stake = stake\n", + " params=replace(\n", + " sim_params,\n", + " SLOTS=int(target_block_num * block_time),\n", + " f=1/block_time\n", " ),\n", - " network=NetworkParams(\n", - " mixnet_delay_mean=mixnet_delay_mean, # seconds\n", - " mixnet_delay_var=4,\n", - " broadcast_delay_mean=2, # second\n", - " pol_proof_time=2, # seconds\n", - " no_network_delay=False\n", - " )\n", - ") for i in [1/2, 1, 2, 3]]\n", + " network=network\n", + ") for block_time in np.array([30]).repeat(PATHS)]\n", "\n", "\n", "for i, sim in enumerate(sims):\n", " print(f\"simulating {i+1}/{len(sims)}\")\n", - " sim.run(seed=0)\n", + " sim.run(seed=i)\n", "\n", "print(\"finished simulation, starting analysis\")\n", - "advs = [sim.adverserial_analysis(should_plot=False) for sim in sims]" + "advs = [sim.adverserial_analysis() for sim in sims]\n", + "\n", + "print(\"cardano parameters\")\n", + "cardano_block_time = 20\n", + "cardano_sims = [Sim(\n", + " params=replace(\n", + " sim_params,\n", + " SLOTS=int(target_block_num * cardano_block_time),\n", + " f=1/cardano_block_time,\n", + " ),\n", + " network=replace(network, blend_hops=0)\n", + ") for _ in range(PATHS)]\n", + "\n", + "for i, sim in enumerate(cardano_sims):\n", + " print(f\"simulating {i+1}/{len(cardano_sims)}\")\n", + " sim.run(seed=i)\n", + "\n", + "cardano_advs = [sim.adverserial_analysis() for sim in cardano_sims]" ] }, { "cell_type": "code", - "execution_count": 501, + "execution_count": null, "id": "87c8d0b8-c8d2-4c49-a9c4-2eaefd41c254", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "MAX=40\n", + "k = 3000\n", + "MAX=min(k, max(max(adv) for adv in advs))\n", + "network_samples = network.empirical_network_delay()\n", + "network_delay_mean = network_samples.mean()\n", + "f_index = list({s.params.f for s in sims})\n", + "hops_index = list({s.network.blend_hops for s in sims})\n", + "delay_index = list({s.network.blending_delay for s in sims})\n", + "colors = ['#855C75FF', '#D9AF6BFF', '#AF6458FF', '#736F4CFF', '#526A83FF', '#625377FF', '#68855CFF', '#9C9C5EFF', '#A06177FF', '#8C785DFF', '#467378FF', '#7C7C7CFF']\n", "\n", "for s in range(len(sims)):\n", - " \n", - " max_depth = advs[s].max() if advs[s].sum() > 0 else 0\n", - " max_depth = min(MAX, max_depth)\n", - " count_by_depth = np.zeros(max_depth)\n", - " for d in range(max_depth):\n", - " count_by_depth[d] = (advs[s] == d).sum() \n", + " print(f'{s+1} / {len(sims)}')\n", " block_time = 1 / sims[s].params.f\n", - " expected_blocks = sims[s].params.SLOTS / block_time\n", - " plt.plot(np.arange(max_depth), count_by_depth / expected_blocks, label=f\"{block_time:.0f}s ~ {block_time / sims[s].network.mixnet_delay_mean:.1f}x mix delay\")\n", + " c = colors[f_index.index(sims[s].params.f)]\n", + " # c = colors[hops_index.index(sims[s].network.blend_hops)]\n", + " # c = colors[delay_index.index(sims[s].network.blending_delay)]\n", + " reorg_depth_analysis(sims[s], advs[s], MAX, color=c, lw=\"1\", label=f\"{block_time:.1f}s ~ {block_time / network_delay_mean:.0f}x net delay\")\n", + " # reorg_depth_analysis(sims[s], advs[s], MAX, color=c, lw=\"1\", label=f\"hops={sims[s].network.blend_hops}\")\n", + " # reorg_depth_analysis(sims[s], advs[s], MAX, color=c, lw=\"1\", label=f\"blending delay={sims[s].network.blending_delay}\")\n", "\n", - "_ = plt.title(f\"reorg depth sensitivity to block time @ {mixnet_delay_mean}s mixnet delay\")\n", + "\n", + "for s in range(len(cardano_sims)):\n", + " reorg_depth_analysis(cardano_sims[s], cardano_advs[s], MAX, lw=\"1\", color=\"k\", label=f\"cardano\")\n", + "\n", + "_ = plt.title(f\"reorg depth sensitivity\")\n", "_ = plt.xlabel(\"reorg depth\")\n", "_ = plt.ylabel(\"frequency (per block)\")\n", - "_ = plt.legend()\n", "_ = plt.yscale(\"log\")\n", "_ = plt.xlim(0, MAX)\n", - "_ = plt.ylim(10**-4, 4)\n" + "_ = plt.ylim(10**-4,None)\n", + "\n", + "# avoid duplicate legend entries with the same label\n", + "handles, labels = plt.gca().get_legend_handles_labels()\n", + "by_label = dict(zip(labels, handles))\n", + "_ = plt.legend(by_label.values(), by_label.keys())" ] }, { "cell_type": "code", - "execution_count": 497, + "execution_count": null, "id": "af11b126-33b6-4b62-868e-b11a0090aa69", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[(150000, 5.0), (300000, 10.0), (600000, 20.0), (900000, 30.0)]" - ] - }, - "execution_count": 497, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "[(s.params.SLOTS, 1 / s.params.f) for s in sims]" + "[(s.params.SLOTS, 1 / s.params.f, s.params.f, s.params.f * s.params.adversary_control) for s in sims]" ] }, { "cell_type": "code", - "execution_count": 514, + "execution_count": null, "id": "23a226b5-b624-4ae9-86bd-2d7201bbb365", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# _ = plt.plot([s.network.mixnet_delay_mean for s in sims], [len(s.honest_chain()) / s.params.SLOTS for s in sims])\n", - "_ = plt.scatter([1 / s.params.f for s in sims], [len(s.honest_chain()) / s.params.SLOTS for s in sims])\n", + "_ = plt.scatter([1 / s.params.f for s in sims + cardano_sims], [len(s.honest_chain()) / s.params.SLOTS for s in sims + cardano_sims])\n", "\n", "_ = plt.title(\"chain growth vs. block time multiple of network delay\")\n", "_ = plt.ylabel(\"chain growth / slot\")\n", - "_ = plt.xlabel(\"block time multiple of network delay\")" + "_ = plt.xlabel(\"block time\")" ] }, { "cell_type": "code", - "execution_count": 499, + "execution_count": null, "id": "317dd511-6fda-44c3-88ff-622460b36665", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# _ = plt.plot([(1 / s.params.f) / s.network.mixnet_delay_mean for s in sims], [len(s.honest_chain()) / s.params.SLOTS for s in sims])\n", - "_ = plt.scatter([s.params.f for s in sims], [len(s.honest_chain()) / len(s.blocks) for s in sims])\n", + "_ = plt.scatter([s.params.f for s in sims + cardano_sims], [len(s.honest_chain()) / len(s.blocks) for s in sims + cardano_sims])\n", "\n", "_ = plt.title(\"block efficiency\")\n", "_ = plt.ylabel(\"% of blocks member of honest chain\")\n", @@ -935,7 +1169,23 @@ { "cell_type": "code", "execution_count": null, - "id": "5818b2d0-ba38-49bd-89c9-e78306f493f1", + "id": "45a7325a-4b98-4967-b5d9-436a6838fded", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "71eab297-4b96-4229-ab82-a9f1d8d23854", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "20f0b7c2-b985-42a2-bf57-77b55228b9ad", "metadata": {}, "outputs": [], "source": [] @@ -957,7 +1207,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.12.9" } }, "nbformat": 4,