1043 lines
48 KiB
Python
1043 lines
48 KiB
Python
#!/usr/bin/env python3
|
|
"""Igneum finality rule V2: checkpoint-level simulation with latency, partitions and eclipses.
|
|
|
|
Rule under test (CLAUDE.md, FINALITY RULE V2, review round 2, 3 October 2026):
|
|
* Vote weight of a key = its blue blocks over a flat trailing 30-day window (DAA time,
|
|
86,400 blocks a day). No damping. Dust threshold DUST blocks: a key below it is not a
|
|
voter and is not counted in any denominator.
|
|
* A checkpoint forms every 30 blocks (blue score 30i). Every voter signs every checkpoint
|
|
it sees while online. Aggregators collect votes; a certificate (a lock) exists once the
|
|
collected signatures reach QUORUM (2/3) of the denominator.
|
|
* ACTIVE denominator: sum over eligible keys of weight x participation, where participation
|
|
= min(1, certified votes of that key over the last PRESENCE (240) checkpoint indices / 240).
|
|
A key whose first block is less than 240 checkpoints old counts as participation 1.
|
|
* TOTAL denominator (the alternative): sum of weight over every eligible key, no factor.
|
|
* Equivocation (one key signing two different checkpoint blocks at one index) zeroes the
|
|
key's weight for the rest of the window once the evidence is seen.
|
|
|
|
Participation bookkeeping has three readings, selected with --pmode. The difference only shows
|
|
when a checkpoint index gets no certificate:
|
|
cert (the brief, literal) an uncertified index contributes 0 certified votes to EVERY key,
|
|
so a stall decays everyone's participation and the denominator shrinks until the
|
|
present signers reach 2/3 of it. Self-healing, and the partition hazard.
|
|
seen an uncertified index credits the keys whose votes the node observed on the wire.
|
|
Silent keys decay, present keys do not. Not objective: each node counts its own view.
|
|
frozen the window is over the last 240 CERTIFIED indices, so a stall freezes participation.
|
|
Fails safe and never recovers liveness within the window.
|
|
|
|
Model (all assumptions, repeated in results_v2.md):
|
|
* Time step = one 30-s slot. The network mines Poisson(30) blocks per slot, split per key by
|
|
hashrate share (perfect difficulty retarget). Every block is blue (GHOSTDAG abstracted).
|
|
* Weight window = 720 hourly buckets of blocks per key (30 days), rolled every hour.
|
|
* A checkpoint index forms on a side each time that side's blue score passes a multiple of
|
|
30, so a partition side mining a fraction s of the hashrate forms checkpoints at s per slot.
|
|
Checkpoint blocks on different sides are different blocks at the same index.
|
|
* Regions: a one-way delay matrix, DELAY between regions, INTRA inside one, lognormal jitter
|
|
per hop. A vote for checkpoint i issued by a key in region r reaches the aggregator in
|
|
region a at t0 + d(src, r) + d(r, a) (+ a per-key extra delay for an eclipsed key).
|
|
One aggregator per region on the side; the certificate forms at the first one to reach
|
|
quorum; its signer set is every vote that arrived there by max(threshold time, t0 + GRACE).
|
|
* Honest keys follow a two-state uptime chain: availability UPTIME (UPTIME_BIG for keys at or
|
|
above 1% of hashrate, a pool with redundant infrastructure), mean outage OUTAGE slots.
|
|
* A partition splits regions into sides, each with its own view (certificates, participation
|
|
ring, blue score). At the heal the views merge: certificates are unioned, two certificates
|
|
at one index with different blocks count as a CONFLICTING LOCK, participation rings are
|
|
OR-merged by index, and any key that signed on two sides at a common index is stripped.
|
|
* Weights are global (a side does not see the other side's blocks for the partition's
|
|
duration; at most 150 minutes of a 30-day window, ignored).
|
|
|
|
Standard library plus numpy. Deterministic for a given --seed.
|
|
|
|
Usage:
|
|
python3 finality_v2.py # every scenario, markdown on stdout
|
|
python3 finality_v2.py --scenarios A,E --delay 5
|
|
python3 finality_v2.py --quick # shortened runs for development
|
|
"""
|
|
|
|
import argparse
|
|
import sys
|
|
import time
|
|
|
|
import numpy as np
|
|
|
|
SLOT_S = 30.0
|
|
BLOCKS_PER_CP = 30
|
|
SLOTS_PER_HOUR = 120
|
|
SLOTS_PER_DAY = 2_880
|
|
WINDOW_HOURS = 720
|
|
WINDOW_BLOCKS = 86_400 * 30
|
|
N_HONEST = 1_000
|
|
PARETO_SHAPE = 1.0
|
|
GEOGRAPHY = (0.45, 0.35, 0.20) # honest hashrate per region, model assumption
|
|
TWO_THIRDS = 2.0 / 3.0
|
|
|
|
|
|
class P:
|
|
"""Parameters. Keyword overrides."""
|
|
|
|
def __init__(self, **kw):
|
|
self.delay = 2.0 # one-way inter-region delay, seconds
|
|
self.intra = 0.1 # one-way intra-region delay, seconds
|
|
self.jitter = 0.25 # lognormal sigma per hop
|
|
self.grace = 15.0 # seconds after t0 during which late votes still enter the certificate
|
|
self.uptime = 0.97 # availability of an honest key under 1% of hashrate
|
|
self.uptime_big = 0.995 # availability of a key at or above 1% of hashrate (redundant pool infrastructure)
|
|
self.big_share = 0.01
|
|
self.outage = 20 # mean outage length, slots (10 minutes)
|
|
self.denom = "active" # "active" or "total"
|
|
self.pmode = "cert" # "cert", "seen", "frozen"
|
|
self.presence = 240 # checkpoints in the participation window
|
|
self.dust = 100 # blocks
|
|
self.quorum = TWO_THIRDS
|
|
self.floor = 0.0 # hybrid: active denominator never below floor x total weight (0 = off)
|
|
self.daa = "none" # "none": a partition side mines at its hashrate share; "full": each side retargets to 30 blocks/slot at once
|
|
self.__dict__.update(kw)
|
|
|
|
def label(self):
|
|
if self.denom == "total":
|
|
return "total"
|
|
s = "active/" + self.pmode
|
|
if self.floor > 0:
|
|
s += "+floor%.2f" % self.floor
|
|
if self.daa != "none":
|
|
s += "+daa"
|
|
return s
|
|
|
|
|
|
class View:
|
|
"""One side's view: participation ring, checkpoint counter, certificates."""
|
|
|
|
def __init__(self, sid, regions, n, presence, next_idx):
|
|
self.sid = sid
|
|
self.regions = list(regions)
|
|
self.ring = np.zeros((presence, n), dtype=np.int8)
|
|
self.ring_idx = np.full(presence, -1, dtype=np.int64)
|
|
self.pcount = np.zeros(n, dtype=np.int32)
|
|
self.next_idx = int(next_idx)
|
|
self.blue = 0.0
|
|
self.certs = {} # idx -> (sid, slot, latency_s)
|
|
self.stalls = [] # (idx, slot)
|
|
self.key_mask = None # keys whose region is on this side
|
|
self.mine_mask = None
|
|
|
|
def clone_ring_from(self, other):
|
|
self.ring[:] = other.ring
|
|
self.ring_idx[:] = other.ring_idx
|
|
self.pcount[:] = other.pcount
|
|
|
|
|
|
class Sim:
|
|
def __init__(self, p, rng, n_regions=3):
|
|
self.p = p
|
|
self.rng = rng
|
|
self.R = int(n_regions)
|
|
self.D = np.full((self.R, self.R), p.delay)
|
|
np.fill_diagonal(self.D, p.intra)
|
|
self.N = 0
|
|
self.hash = np.zeros(0)
|
|
self.region = np.zeros(0, dtype=np.int64)
|
|
self.online = np.zeros(0, dtype=bool)
|
|
self.flaky = np.zeros(0, dtype=bool)
|
|
self.signs = np.zeros(0, dtype=bool)
|
|
self.equiv = np.zeros(0, dtype=bool)
|
|
self.stripped = np.zeros(0, dtype=bool)
|
|
self.extra_delay = np.zeros(0)
|
|
self.first_idx = np.zeros(0, dtype=np.int64)
|
|
self.buckets = np.zeros((WINDOW_HOURS, 0))
|
|
self.weight = np.zeros(0)
|
|
self.slot = 0
|
|
self.views = []
|
|
self.next_sid = 1
|
|
self.records = [] # (slot, idx, sid, latency_s or -1, signed/denom, denom/total)
|
|
self.conflicts = [] # (idx, slot the second certificate existed)
|
|
self.q_on = 1.0 / p.outage
|
|
self.q_off = np.zeros(0)
|
|
|
|
# ------------------------------------------------------------- keys
|
|
def add_keys(self, hashes, regions, flaky=True, equiv=False, signs=True):
|
|
hashes = np.asarray(hashes, dtype=float)
|
|
regions = np.asarray(regions, dtype=np.int64)
|
|
n = hashes.size
|
|
self.hash = np.concatenate([self.hash, hashes])
|
|
self.region = np.concatenate([self.region, regions])
|
|
self.online = np.concatenate([self.online, np.ones(n, dtype=bool)])
|
|
self.flaky = np.concatenate([self.flaky, np.full(n, flaky, dtype=bool)])
|
|
self.signs = np.concatenate([self.signs, np.full(n, signs, dtype=bool)])
|
|
self.equiv = np.concatenate([self.equiv, np.full(n, equiv, dtype=bool)])
|
|
self.stripped = np.concatenate([self.stripped, np.zeros(n, dtype=bool)])
|
|
self.extra_delay = np.concatenate([self.extra_delay, np.zeros(n)])
|
|
self.first_idx = np.concatenate([self.first_idx, np.full(n, -1, dtype=np.int64)])
|
|
self.buckets = np.concatenate([self.buckets, np.zeros((WINDOW_HOURS, n))], axis=1)
|
|
self.weight = np.concatenate([self.weight, np.zeros(n)])
|
|
first = self.N
|
|
self.N += n
|
|
self.q_off = np.concatenate([self.q_off, np.zeros(n)])
|
|
self.set_uptime()
|
|
return np.arange(first, self.N)
|
|
|
|
def set_uptime(self):
|
|
"""Per-key off-switch probability per slot from the size-dependent availability. Call after hashrate changes."""
|
|
tot = self.hash.sum()
|
|
share = self.hash / tot if tot > 0 else np.zeros(self.N)
|
|
u = np.where(share >= self.p.big_share, self.p.uptime_big, self.p.uptime)
|
|
self.q_off = self.q_on * (1.0 - u) / u
|
|
|
|
def warm_start(self):
|
|
"""Fill the 30-day window as if the mining keys had been mining at their share for 30 days."""
|
|
share = self.hash / self.hash.sum()
|
|
lam = 3_600.0 * share
|
|
for h in range(WINDOW_HOURS):
|
|
self.buckets[h] = self.rng.poisson(lam)
|
|
self.weight = self.buckets.sum(axis=0)
|
|
self.first_idx[self.hash > 0] = -10 ** 9
|
|
self.slot = 0
|
|
|
|
def init_views(self, warm):
|
|
v = View(0, range(self.R), self.N, self.p.presence, next_idx=(WINDOW_BLOCKS // BLOCKS_PER_CP if warm else 0))
|
|
self._set_masks(v)
|
|
if warm:
|
|
elig = (self.weight >= self.p.dust) & self.signs
|
|
v.ring[:] = elig.astype(np.int8)[None, :]
|
|
v.ring_idx[:] = np.arange(v.next_idx - self.p.presence, v.next_idx)
|
|
v.pcount[:] = v.ring.sum(axis=0)
|
|
self.views = [v]
|
|
self.next_sid = 1
|
|
|
|
def _set_masks(self, v):
|
|
v.key_mask = np.isin(self.region, v.regions)
|
|
v.mine_mask = v.key_mask.copy()
|
|
|
|
# ------------------------------------------------------------- partitions
|
|
def split(self, groups):
|
|
base = self.views[0]
|
|
new = []
|
|
for g in groups:
|
|
v = View(self.next_sid, g, self.N, self.p.presence, next_idx=base.next_idx)
|
|
self.next_sid += 1
|
|
v.clone_ring_from(base)
|
|
self._set_masks(v)
|
|
new.append(v)
|
|
self.split_idx = base.next_idx
|
|
self.views = new
|
|
|
|
def heal(self):
|
|
views = self.views
|
|
P_ = self.p.presence
|
|
nxt = max(v.next_idx for v in views)
|
|
m = View(self.next_sid, range(self.R), self.N, P_, next_idx=nxt)
|
|
self.next_sid += 1
|
|
self._set_masks(m)
|
|
for i in range(max(0, nxt - P_), nxt):
|
|
row = i % P_
|
|
acc = np.zeros(self.N, dtype=np.int8)
|
|
hit = False
|
|
for v in views:
|
|
if v.ring_idx[row] == i:
|
|
acc |= v.ring[row]
|
|
hit = True
|
|
if hit:
|
|
m.ring[row] = acc
|
|
m.ring_idx[row] = i
|
|
m.pcount[:] = m.ring.sum(axis=0)
|
|
# certificates and conflicts
|
|
for v in views:
|
|
for idx, (sid, slot, lat) in v.certs.items():
|
|
if idx in m.certs and m.certs[idx][0] != sid:
|
|
self.conflicts.append((idx, max(slot, m.certs[idx][1])))
|
|
else:
|
|
m.certs.setdefault(idx, (sid, slot, lat))
|
|
m.stalls.extend(v.stalls)
|
|
# equivocation evidence: an equivocating key signed every side's checkpoint at every common index
|
|
common = min(v.next_idx for v in views) > self.split_idx
|
|
if common and self.equiv.any():
|
|
self.stripped |= self.equiv
|
|
self.strip_slot = self.slot
|
|
self.views = [m]
|
|
|
|
# ------------------------------------------------------------- stepping
|
|
def run(self, n_slots, snap=None):
|
|
"""snap = (every_n_slots, fn(sim)) called before the step on matching slots."""
|
|
for _ in range(int(n_slots)):
|
|
if snap is not None and self.slot % snap[0] == 0:
|
|
snap[1](self)
|
|
self.step()
|
|
|
|
def step(self):
|
|
p = self.p
|
|
slot = self.slot
|
|
tot = self.hash.sum()
|
|
if p.daa == "full" and len(self.views) > 1:
|
|
blocks = np.zeros(self.N)
|
|
for v in self.views:
|
|
side_tot = self.hash[v.mine_mask].sum()
|
|
if side_tot > 0:
|
|
blocks[v.mine_mask] = self.rng.poisson(BLOCKS_PER_CP * self.hash[v.mine_mask] / side_tot)
|
|
else:
|
|
blocks = self.rng.poisson(BLOCKS_PER_CP * self.hash / tot) if tot > 0 else np.zeros(self.N)
|
|
hp = (slot // SLOTS_PER_HOUR) % WINDOW_HOURS
|
|
if slot % SLOTS_PER_HOUR == 0:
|
|
self.weight -= self.buckets[hp]
|
|
self.buckets[hp] = 0.0
|
|
self.buckets[hp] += blocks
|
|
self.weight += blocks
|
|
gidx = max(v.next_idx for v in self.views)
|
|
newly = (blocks > 0) & (self.first_idx == -1)
|
|
if newly.any():
|
|
self.first_idx[newly] = gidx
|
|
r = self.rng.random(self.N)
|
|
flip = np.where(self.online, r < self.q_off, r < self.q_on) & self.flaky
|
|
self.online ^= flip
|
|
for v in self.views:
|
|
v.blue += blocks[v.mine_mask].sum()
|
|
while v.blue >= BLOCKS_PER_CP:
|
|
v.blue -= BLOCKS_PER_CP
|
|
self.checkpoint(v, blocks)
|
|
self.slot += 1
|
|
|
|
def participation(self, v, idx):
|
|
part = np.minimum(1.0, v.pcount / float(self.p.presence))
|
|
new = (self.first_idx > idx - self.p.presence) & (self.first_idx >= 0)
|
|
part[new] = 1.0
|
|
return part
|
|
|
|
def checkpoint(self, v, blocks):
|
|
p = self.p
|
|
idx = v.next_idx
|
|
v.next_idx += 1
|
|
t0 = self.slot * SLOT_S
|
|
# miner of the checkpoint block: a key on this side weighted by its blocks this slot
|
|
bm = blocks * v.mine_mask
|
|
cum = np.cumsum(bm)
|
|
if cum[-1] > 0:
|
|
j = int(np.searchsorted(cum, self.rng.random() * cum[-1], side="right"))
|
|
src = int(self.region[min(j, self.N - 1)])
|
|
else:
|
|
src = v.regions[0]
|
|
jit1 = np.exp(self.rng.normal(0.0, p.jitter, self.R))
|
|
jit2 = np.exp(self.rng.normal(0.0, p.jitter, (self.R, self.R)))
|
|
elig = (self.weight >= p.dust) & ~self.stripped
|
|
voters = elig & self.online & self.signs & (v.key_mask | self.equiv)
|
|
if p.denom == "active":
|
|
denom = float((self.weight * self.participation(v, idx))[elig].sum())
|
|
else:
|
|
denom = float(self.weight[elig].sum())
|
|
total = float(self.weight[elig].sum())
|
|
if p.denom == "active" and p.floor > 0:
|
|
denom = max(denom, p.floor * total)
|
|
need = p.quorum * denom
|
|
vi = np.flatnonzero(voters)
|
|
signed_w = float(self.weight[vi].sum())
|
|
ratio = signed_w / denom if denom > 0 else 0.0
|
|
best = None
|
|
if denom > 0 and vi.size > 0:
|
|
w = self.weight[vi]
|
|
reg = self.region[vi]
|
|
hop1 = np.where(self.equiv[vi], p.intra, self.D[src, reg] * jit1[reg])
|
|
issue = t0 + hop1 + self.extra_delay[vi]
|
|
for a in v.regions:
|
|
hop2 = np.where(self.equiv[vi], p.intra, self.D[reg, a] * jit2[reg, a])
|
|
arr = issue + hop2
|
|
order = np.argsort(arr, kind="stable")
|
|
cw = np.cumsum(w[order])
|
|
k = int(np.searchsorted(cw, need))
|
|
if k < cw.size:
|
|
thr = float(arr[order[k]])
|
|
if best is None or thr < best[0]:
|
|
best = (thr, arr)
|
|
if best is not None:
|
|
thr, arr = best
|
|
lat = thr - t0
|
|
seal = max(thr, t0 + p.grace)
|
|
mask = np.zeros(self.N, dtype=np.int8)
|
|
mask[vi[arr <= seal]] = 1
|
|
v.certs[idx] = (v.sid, self.slot, lat)
|
|
self._push(v, idx, mask)
|
|
self.records.append((self.slot, idx, v.sid, lat, ratio, denom / total if total > 0 else 0.0))
|
|
else:
|
|
v.stalls.append((idx, self.slot))
|
|
if p.pmode == "cert":
|
|
self._push(v, idx, np.zeros(self.N, dtype=np.int8))
|
|
elif p.pmode == "seen":
|
|
self._push(v, idx, voters.astype(np.int8))
|
|
# frozen: no ring update
|
|
self.records.append((self.slot, idx, v.sid, -1.0, ratio, denom / total if total > 0 else 0.0))
|
|
|
|
def _push(self, v, idx, mask):
|
|
row = idx % self.p.presence
|
|
v.pcount -= v.ring[row]
|
|
v.ring[row] = mask
|
|
v.pcount += mask
|
|
v.ring_idx[row] = idx
|
|
|
|
# ------------------------------------------------------------- queries
|
|
def recs(self):
|
|
return np.array(self.records, dtype=float).reshape(-1, 6)
|
|
|
|
def elig_mask(self):
|
|
return (self.weight >= self.p.dust) & ~self.stripped
|
|
|
|
def share(self, keys):
|
|
e = self.elig_mask()
|
|
tot = self.weight[e].sum()
|
|
if tot <= 0:
|
|
return 0.0
|
|
m = np.zeros(self.N, dtype=bool)
|
|
m[keys] = True
|
|
return float(self.weight[m & e].sum() / tot)
|
|
|
|
|
|
# ---------------------------------------------------------------- helpers
|
|
|
|
def pareto_hashrates(rng, n, total=1.0):
|
|
h = rng.pareto(PARETO_SHAPE, n) + 1.0
|
|
return h * (total / h.sum())
|
|
|
|
|
|
def assign_regions(hashes, targets):
|
|
"""Largest key first, each to the region with the largest remaining hashrate deficit."""
|
|
targets = np.asarray(targets, dtype=float)
|
|
tot = hashes.sum()
|
|
filled = np.zeros(targets.size)
|
|
reg = np.zeros(hashes.size, dtype=np.int64)
|
|
for i in np.argsort(-hashes):
|
|
r = int(np.argmax(targets * tot - filled))
|
|
reg[i] = r
|
|
filled[r] += hashes[i]
|
|
return reg
|
|
|
|
|
|
def pick_weight_subset(rng, weights, frac):
|
|
"""Random keys whose weight sums to about frac of total, never over."""
|
|
target = frac * weights.sum()
|
|
mask = np.zeros(weights.size, dtype=bool)
|
|
acc = 0.0
|
|
for i in rng.permutation(weights.size):
|
|
if acc + weights[i] <= target:
|
|
mask[i] = True
|
|
acc += weights[i]
|
|
return mask, acc / weights.sum()
|
|
|
|
|
|
def gini(x):
|
|
x = np.sort(np.asarray(x, dtype=float))
|
|
n = x.size
|
|
if n == 0 or x.sum() == 0:
|
|
return 0.0
|
|
cum = np.cumsum(x)
|
|
return (n + 1 - 2.0 * cum.sum() / cum[-1]) / n
|
|
|
|
|
|
def pct(x, d=1):
|
|
return ("%%.%df%%%%" % d) % (100.0 * x)
|
|
|
|
|
|
def md_table(headers, rows):
|
|
out = ["| " + " | ".join(str(h) for h in headers) + " |", "|" + "---|" * len(headers)]
|
|
for r in rows:
|
|
out.append("| " + " | ".join(str(c) for c in r) + " |")
|
|
return "\n".join(out)
|
|
|
|
|
|
def lat_stats(recs, s_from=0, s_to=None):
|
|
if s_to is None:
|
|
s_to = np.inf
|
|
sel = recs[(recs[:, 0] >= s_from) & (recs[:, 0] < s_to)]
|
|
lat = sel[:, 3]
|
|
ok = lat >= 0
|
|
n = int(sel.shape[0])
|
|
st = int((~ok).sum())
|
|
cps = np.floor(lat[ok] / SLOT_S)
|
|
d = dict(n=n, stalls=st, c0=int((cps == 0).sum()), c1=int((cps == 1).sum()), c2=int((cps >= 2).sum()))
|
|
if ok.any():
|
|
d.update(med=float(np.median(lat[ok])), p99=float(np.percentile(lat[ok], 99)), mx=float(lat[ok].max()),
|
|
ratio_min=float(sel[ok, 4].min()), ratio_med=float(np.median(sel[ok, 4])))
|
|
else:
|
|
d.update(med=float("nan"), p99=float("nan"), mx=float("nan"), ratio_min=float("nan"), ratio_med=float("nan"))
|
|
return d
|
|
|
|
|
|
def lat_row(label, d):
|
|
return [label, d["n"], d["c0"], d["c1"], d["c2"], d["stalls"], "%.1f" % d["med"], "%.1f" % d["p99"], "%.1f" % d["mx"],
|
|
"%.3f" % d["ratio_min"]]
|
|
|
|
|
|
LAT_HEADERS = ["run", "checkpoints", "locked in slot 0", "slot 1", "slot 2+", "stalled", "median s", "p99 s", "max s",
|
|
"min signed/denominator"]
|
|
|
|
|
|
def first_lock_after(recs, slot, sid=None):
|
|
sel = recs[(recs[:, 0] >= slot) & (recs[:, 3] >= 0)]
|
|
if sid is not None:
|
|
sel = sel[sel[:, 2] == sid]
|
|
if sel.shape[0] == 0:
|
|
return None
|
|
return int(sel[0, 0])
|
|
|
|
|
|
def stalls_between(recs, s_from, s_to, sid=None):
|
|
sel = recs[(recs[:, 0] >= s_from) & (recs[:, 0] < s_to) & (recs[:, 3] < 0)]
|
|
if sid is not None:
|
|
sel = sel[sel[:, 2] == sid]
|
|
return int(sel.shape[0])
|
|
|
|
|
|
def fmt_min(slots):
|
|
if slots is None:
|
|
return "never"
|
|
m = slots * SLOT_S / 60.0
|
|
if m < 120:
|
|
return "%.0f min" % m
|
|
if m < 48 * 60:
|
|
return "%.1f h" % (m / 60.0)
|
|
return "%.1f d" % (m / 1440.0)
|
|
|
|
|
|
def fmt_days(slots):
|
|
return "never" if slots is None else "%.1f" % (slots / SLOTS_PER_DAY)
|
|
|
|
|
|
def build_honest(p, seed, n_regions=3, geography=GEOGRAPHY, big_pool=None):
|
|
rng = np.random.default_rng(seed)
|
|
sim = Sim(p, rng, n_regions=n_regions)
|
|
if big_pool is None:
|
|
h = pareto_hashrates(rng, N_HONEST)
|
|
reg = assign_regions(h, geography)
|
|
sim.add_keys(h, reg, flaky=True)
|
|
pool = None
|
|
else:
|
|
h = pareto_hashrates(rng, N_HONEST - 1, total=1.0 - big_pool)
|
|
reg = assign_regions(h, geography)
|
|
sim.add_keys(h, reg, flaky=True)
|
|
pool = int(sim.add_keys([big_pool], [3], flaky=False)[0])
|
|
return sim, rng, pool
|
|
|
|
|
|
# ---------------------------------------------------------------- scenarios
|
|
|
|
def scenario_a(args):
|
|
out = ["### A. Steady state from zero history, 1,000 honest keys, 3 regions %s, %d days" % (
|
|
"/".join(pct(g, 0) for g in GEOGRAPHY), args.days_a), ""]
|
|
days = args.days_a
|
|
snaps = {}
|
|
lat_rows = []
|
|
prop_rows = []
|
|
for denom in ("active", "total"):
|
|
p = P(denom=denom, delay=args.delay)
|
|
sim, rng, _ = build_honest(p, args.seed)
|
|
sim.init_views(warm=False)
|
|
series = []
|
|
|
|
def snap(s, series=series):
|
|
e = s.elig_mask()
|
|
series.append((s.slot // SLOTS_PER_DAY, s.weight.sum() / WINDOW_BLOCKS, int((~e).sum())))
|
|
|
|
sim.run(days * SLOTS_PER_DAY, snap=(SLOTS_PER_DAY, snap))
|
|
snap(sim)
|
|
recs = sim.recs()
|
|
snaps[denom] = series
|
|
lat_rows.append(lat_row("%s, days 0 to 1" % denom, lat_stats(recs, 0, SLOTS_PER_DAY)))
|
|
lat_rows.append(lat_row("%s, days 1 to 30" % denom, lat_stats(recs, SLOTS_PER_DAY, 30 * SLOTS_PER_DAY)))
|
|
lat_rows.append(lat_row("%s, days 30 to %d" % (denom, days), lat_stats(recs, 30 * SLOTS_PER_DAY, None)))
|
|
w = sim.weight
|
|
ws = w / w.sum()
|
|
hs = sim.hash / sim.hash.sum()
|
|
order = np.argsort(-hs)
|
|
rel = ws / hs
|
|
prop_rows.append([denom, "%.5f" % np.corrcoef(hs, ws)[0, 1], "%.3f / %.3f" % (gini(hs), gini(ws)),
|
|
pct(hs[order[0]]) + " / " + pct(ws[order[0]]),
|
|
pct(hs[order[:10]].sum()) + " / " + pct(ws[order[:10]].sum()),
|
|
pct(hs[order[500:]].sum()) + " / " + pct(ws[order[500:]].sum()),
|
|
"%.3f / %.3f" % (rel.min(), rel.max()), int((rel < 0.9).sum()), int((~sim.elig_mask()).sum())])
|
|
# genesis stall run
|
|
first = first_lock_after(recs, 0)
|
|
snaps[denom + "_first"] = first
|
|
s = snaps["active"]
|
|
ramp = []
|
|
for d in (1, 2, 5, 10, 20, 30, 31, 45, days):
|
|
row = [x for x in s if x[0] == d]
|
|
if row:
|
|
ramp.append([d, pct(row[0][1]), row[0][2]])
|
|
out.append("Weight ramp (active run; the total run mines the same blocks):")
|
|
out.append("")
|
|
out.append(md_table(["day", "total weight / full window", "keys under dust (100 blocks)"], ramp))
|
|
out.append("")
|
|
out.append("Weight against hashrate at day %d:" % days)
|
|
out.append("")
|
|
out.append(md_table(["denominator", "corr(hash, weight)", "Gini hash / weight", "top-1 hash / weight",
|
|
"top-10 hash / weight", "bottom-500 hash / weight", "min / max weight:hash", "keys under 0.9x",
|
|
"dust keys"], prop_rows))
|
|
out.append("")
|
|
out.append("Lock latency (seconds from checkpoint block to quorum; slot = 30 s), inter-region delay %.1f s:" % args.delay)
|
|
out.append("")
|
|
out.append(md_table(LAT_HEADERS, lat_rows))
|
|
out.append("")
|
|
out.append("First lock from genesis: active at slot %s, total at slot %s (the first checkpoints have no key above dust)." % (
|
|
snaps["active_first"], snaps["total_first"]))
|
|
out.append("")
|
|
# delay comparison, short warm-started runs
|
|
rows = []
|
|
for delay in (0.5, 2.0, 5.0):
|
|
for grace in (args.grace,):
|
|
p = P(denom="active", delay=delay, grace=grace)
|
|
sim, rng, _ = build_honest(p, args.seed)
|
|
sim.warm_start()
|
|
sim.init_views(warm=True)
|
|
sim.run(args.days_delay * SLOTS_PER_DAY)
|
|
recs = sim.recs()
|
|
d = lat_stats(recs)
|
|
# participation of the slowest region
|
|
v = sim.views[0]
|
|
part = sim.participation(v, v.next_idx)
|
|
by_region = ["%.3f" % np.average(part[sim.region == r], weights=sim.weight[sim.region == r]) for r in range(3)]
|
|
rows.append(lat_row("delay %.1f s, grace %.0f s, %d days warm" % (delay, grace, args.days_delay), d) + ["/".join(by_region)])
|
|
out.append("Delay sweep, warm-started (steady-state weights), active denominator. Last column: weight-averaged participation per region.")
|
|
out.append("")
|
|
out.append(md_table(LAT_HEADERS + ["participation r0/r1/r2"], rows))
|
|
return "\n".join(out)
|
|
|
|
|
|
def scenario_b(args):
|
|
out = ["### B. Rental burst at day 60, one public key with a x honest hashrate, signs every checkpoint", ""]
|
|
mults = (1, 2, 4, 9)
|
|
series = {}
|
|
cross = {}
|
|
for a in mults:
|
|
p = P(denom="active", delay=args.delay)
|
|
sim, rng, _ = build_honest(p, args.seed, n_regions=4)
|
|
att = int(sim.add_keys([0.0], [3], flaky=False)[0])
|
|
sim.warm_start()
|
|
sim.init_views(warm=True)
|
|
sim.run(SLOTS_PER_HOUR) # one hour of baseline
|
|
t_event = sim.slot
|
|
sim.hash[att] = float(a)
|
|
s = []
|
|
c13 = c23 = None
|
|
for day in range(1, args.days_b + 1):
|
|
for _ in range(SLOTS_PER_DAY // 24):
|
|
sim.run(24)
|
|
sh = sim.share([att])
|
|
if c13 is None and sh >= 1.0 / 3.0:
|
|
c13 = sim.slot - t_event
|
|
if c23 is None and sh >= TWO_THIRDS:
|
|
c23 = sim.slot - t_event
|
|
s.append((day, sim.share([att])))
|
|
recs = sim.recs()
|
|
series[a] = s
|
|
cross[a] = (c13, c23, lat_stats(recs, t_event, None))
|
|
pick = [d for d in (1, 5, 10, 15, 20, 25, 30, 35) if d <= args.days_b]
|
|
rows = []
|
|
for d in pick:
|
|
row = ["+%d" % d]
|
|
for a in mults:
|
|
sim_v = dict(series[a])[d]
|
|
formula = min(d / 30.0, 1.0) * a / (1.0 + a)
|
|
row.append("%s / %s" % (pct(sim_v), pct(formula)))
|
|
rows.append(row)
|
|
out.append("Attacker weight share, simulated / formula (t/30) x a/(1+a):")
|
|
out.append("")
|
|
out.append(md_table(["day after burst"] + ["a=%d (%s of hashrate)" % (a, pct(a / (1.0 + a), 0)) for a in mults], rows))
|
|
out.append("")
|
|
ev = [
|
|
["crosses 1/3 (honest alone can no longer lock), sim day"] + [fmt_days(cross[a][0]) for a in mults],
|
|
["crosses 1/3, formula 10(1+a)/a"] + ["%.1f" % (10.0 * (1 + a) / a) for a in mults],
|
|
["crosses 2/3 (locks alone), sim day"] + [fmt_days(cross[a][1]) for a in mults],
|
|
["crosses 2/3, formula 20(1+a)/a"] + ["%.1f" % (20.0 * (1 + a) / a) if 20.0 * (1 + a) / a <= 30 else "never (ceiling %s)" % pct(a / (1 + a), 0) for a in mults],
|
|
["max abs deviation sim vs formula, days 1 to 30, points"] + [
|
|
"%.2f" % (100 * max(abs(v - min(d / 30.0, 1.0) * a / (1.0 + a)) for d, v in series[a] if d <= 30)) for a in mults],
|
|
["stalled checkpoints after the burst"] + [cross[a][2]["stalls"] for a in mults],
|
|
]
|
|
out.append(md_table(["event"] + ["a=%d" % a for a in mults], ev))
|
|
return "\n".join(out)
|
|
|
|
|
|
def scenario_c(args):
|
|
out = ["### C. Silent set: a random set holding x of weight stops signing at day 60 (hour 3 of the run) and keeps mining", ""]
|
|
fracs = (0.34, 0.40, 0.45, 0.50, 0.55)
|
|
configs = [("active", "cert", args.hours_c, 0.0, 240), ("active", "seen", args.hours_c, 0.0, 240),
|
|
("active", "frozen", args.hours_c, 0.0, 240), ("active", "cert", args.hours_c_total, 0.0, 2880),
|
|
("active", "cert", args.hours_c_total, 0.8, 240), ("active", "cert", args.hours_c_total, 0.85, 240),
|
|
("total", "cert", args.hours_c_total, 0.0, 240)]
|
|
labels = []
|
|
for denom, pmode, hours, floor, presence in configs:
|
|
lab = P(denom=denom, pmode=pmode, floor=floor, presence=presence).label()
|
|
if presence != 240:
|
|
lab += ", presence %d" % presence
|
|
labels.append(lab)
|
|
rows = []
|
|
detail = []
|
|
for frac in fracs:
|
|
row = [pct(frac, 0)]
|
|
for denom, pmode, hours, floor, presence in configs:
|
|
p = P(denom=denom, pmode=pmode, delay=args.delay, floor=floor, presence=presence)
|
|
sim, rng, _ = build_honest(p, args.seed)
|
|
sim.warm_start()
|
|
sim.init_views(warm=True)
|
|
sim.run(3 * SLOTS_PER_HOUR)
|
|
silent, got = pick_weight_subset(rng, sim.weight, frac)
|
|
sim.signs[silent] = False
|
|
t_event = sim.slot
|
|
v0 = sim.views[0]
|
|
e0 = sim.elig_mask()
|
|
s_on = float(sim.weight[e0 & sim.online & ~silent].sum() / sim.weight[e0].sum())
|
|
p0 = float((sim.weight * sim.participation(v0, v0.next_idx))[e0].sum() / sim.weight[e0].sum())
|
|
predicted = max(0, int(round(p.presence * (p0 - 1.5 * s_on))))
|
|
sim.run(int(hours * SLOTS_PER_HOUR))
|
|
recs = sim.recs()
|
|
fl = first_lock_after(recs, t_event)
|
|
st = stalls_between(recs, t_event, sim.slot)
|
|
v = sim.views[0]
|
|
part = sim.participation(v, v.next_idx)
|
|
sil_part = float(np.average(part[silent], weights=sim.weight[silent]))
|
|
# stalls after the first lock (does it stay locked?)
|
|
later = stalls_between(recs, fl, sim.slot) if fl is not None else st
|
|
fl_txt = "never (%s)" % fmt_min(sim.slot - t_event) if fl is None else fmt_min(fl - t_event)
|
|
row.append("%s, %d stalled" % (fl_txt, st))
|
|
if denom == "active" and pmode == "cert" and floor == 0 and presence == 240:
|
|
tail = recs[(recs[:, 0] >= sim.slot - SLOTS_PER_HOUR) & (recs[:, 3] >= 0)]
|
|
detail.append([pct(frac, 0), pct(got), int(silent.sum()), pct(s_on), "%.3f" % p0, predicted, fl_txt, st, later, "%.3f" % sil_part,
|
|
"%.3f" % (np.median(tail[:, 4]) if tail.shape[0] else float("nan")),
|
|
"%.3f" % (np.median(tail[:, 5]) if tail.shape[0] else float("nan"))])
|
|
rows.append(row)
|
|
out.append("Time from the event to the first lock, and checkpoints stalled in the run (%d h for the first three columns, %d h for the rest):" % (
|
|
args.hours_c, args.hours_c_total))
|
|
out.append("")
|
|
out.append(md_table(["silent weight"] + labels, rows))
|
|
out.append("")
|
|
out.append("Active/cert detail. Predicted stalls = presence x (p0 - 1.5 x online signing share), where p0 is the weight-averaged participation at the event:")
|
|
out.append("")
|
|
out.append(md_table(["silent weight", "picked", "keys", "online signing share at event", "p0", "predicted stalls", "first lock", "stalled", "stalled after first lock",
|
|
"silent participation at end", "signed/denominator at end (median, last hour)",
|
|
"active/total at end"], detail))
|
|
return "\n".join(out)
|
|
|
|
|
|
def scenario_d(args):
|
|
out = ["### D. Churn: a random set holding x of weight stops mining and signing at day 60 (hour 3 of the run)", ""]
|
|
fracs = (0.35, 0.50)
|
|
rows = []
|
|
dconfigs = [P(denom="active", delay=args.delay), P(denom="active", presence=2880, delay=args.delay),
|
|
P(denom="active", floor=0.8, delay=args.delay), P(denom="active", floor=0.85, delay=args.delay),
|
|
P(denom="total", delay=args.delay)]
|
|
for frac in fracs:
|
|
for p in dconfigs:
|
|
days = args.days_d35 if frac < 0.4 else args.days_d50
|
|
denom = p.label() + (", presence 2880" if p.presence == 2880 else "")
|
|
sim, rng, _ = build_honest(p, args.seed)
|
|
sim.warm_start()
|
|
sim.init_views(warm=True)
|
|
sim.run(3 * SLOTS_PER_HOUR)
|
|
gone, got = pick_weight_subset(rng, sim.weight, frac)
|
|
sim.signs[gone] = False
|
|
sim.online[gone] = False
|
|
sim.flaky[gone] = False
|
|
sim.hash[gone] = 0.0
|
|
t_event = sim.slot
|
|
live = ~gone
|
|
sim.run(int(days * SLOTS_PER_DAY))
|
|
recs = sim.recs()
|
|
fl = first_lock_after(recs, t_event)
|
|
st = stalls_between(recs, t_event, sim.slot)
|
|
later = stalls_between(recs, fl, sim.slot) if fl is not None else 0
|
|
live_share_at = None
|
|
rows.append([pct(frac, 0), pct(got), int(gone.sum()), denom,
|
|
"never in %s" % fmt_min(sim.slot - t_event) if fl is None else fmt_min(fl - t_event),
|
|
st, later, pct(sim.share(np.flatnonzero(live)))])
|
|
out.append(md_table(["churn weight", "picked", "keys", "denominator", "first lock after the event", "stalled checkpoints",
|
|
"stalled after first lock", "live share of total weight at end of run"], rows))
|
|
out.append("")
|
|
out.append("Analytic (perfect retarget): live share of total weight on day t = 1 - x(30 - t)/30, so the total "
|
|
"denominator recovers at t = 30(1 - 1/(3x)): never for x <= 1/3, day 1.4 at 35%, day 10 at 50%.")
|
|
return "\n".join(out)
|
|
|
|
|
|
def run_partition(seed, fracs, att_share, dur_min, p, pre_min=60, post_min=180):
|
|
rng = np.random.default_rng(seed)
|
|
nR = max(3, len(fracs) + 1)
|
|
sim = Sim(p, rng, n_regions=nR)
|
|
h = pareto_hashrates(rng, N_HONEST)
|
|
reg = assign_regions(h, fracs)
|
|
sim.add_keys(h, reg, flaky=True)
|
|
groups = [[i] for i in range(len(fracs))]
|
|
att = None
|
|
if att_share > 0:
|
|
att = int(sim.add_keys([att_share / (1.0 - att_share)], [len(fracs)], flaky=False, equiv=True)[0])
|
|
groups[0].append(len(fracs))
|
|
sim.warm_start()
|
|
sim.init_views(warm=True)
|
|
sim.run(pre_min * 2)
|
|
t_split = sim.slot
|
|
sim.split(groups)
|
|
sides = [v.sid for v in sim.views]
|
|
sim.run(dur_min * 2)
|
|
t_heal = sim.slot
|
|
sim.heal()
|
|
sim.run(post_min * 2)
|
|
recs = sim.recs()
|
|
res = dict(conflicts=len(sim.conflicts), t_split=t_split, t_heal=t_heal)
|
|
res["first_conflict_min"] = (min(c[1] for c in sim.conflicts) - t_split) / 2.0 if sim.conflicts else None
|
|
res["side_first_lock"] = []
|
|
res["side_locks"] = []
|
|
res["side_stalls"] = []
|
|
for sid in sides:
|
|
fl = first_lock_after(recs[recs[:, 0] < t_heal], t_split, sid=sid)
|
|
res["side_first_lock"].append(None if fl is None else (fl - t_split) / 2.0)
|
|
sel = recs[(recs[:, 0] >= t_split) & (recs[:, 0] < t_heal) & (recs[:, 2] == sid)]
|
|
res["side_locks"].append(int((sel[:, 3] >= 0).sum()))
|
|
res["side_stalls"].append(int((sel[:, 3] < 0).sum()))
|
|
res["post_stalls"] = stalls_between(recs, t_heal, sim.slot)
|
|
fl = first_lock_after(recs, t_heal)
|
|
res["post_first_lock_min"] = None if fl is None else (fl - t_heal) / 2.0
|
|
res["att_share"] = sim.share([att]) if att is not None else 0.0
|
|
return res
|
|
|
|
|
|
def fm(m):
|
|
return "never" if m is None else "%.0f" % m
|
|
|
|
|
|
def scenario_e(args):
|
|
out = ["### E. Partition: honest weight split across sides for a set time, then healed", ""]
|
|
configs = [P(denom="active", pmode="cert", delay=args.delay), P(denom="active", pmode="seen", delay=args.delay),
|
|
P(denom="total", delay=args.delay)]
|
|
splits = [("50/50", [0.5, 0.5]), ("33/33/34", [0.33, 0.33, 0.34])]
|
|
rows_conf = []
|
|
rows_first = []
|
|
for name, fr in splits:
|
|
for att in (0.0, 0.34):
|
|
for dur in (30, 90, 150):
|
|
rc = [name, pct(att, 0), dur]
|
|
rf = [name, pct(att, 0), dur]
|
|
for p in configs:
|
|
r = run_partition(args.seed, fr, att, dur, p)
|
|
rc.append("%d%s" % (r["conflicts"], "" if r["conflicts"] == 0 else " (first at %s min)" % fm(r["first_conflict_min"])))
|
|
rf.append(" / ".join(fm(x) for x in r["side_first_lock"]) + " ; post-heal stalls %d" % r["post_stalls"])
|
|
rows_conf.append(rc)
|
|
rows_first.append(rf)
|
|
labels = [p.label() for p in configs]
|
|
out.append("Conflicting locks (two certificates at one index, different blocks). Attacker = equivocating key holding the stated share of total weight, honest weight split as stated. Pass needs 0 at 0% attacker for 30, 90 and 150 min.")
|
|
out.append("")
|
|
out.append(md_table(["honest split", "attacker", "partition min"] + labels, rows_conf))
|
|
out.append("")
|
|
out.append("Minutes after the split until each side's first lock (side order as in the split; attacker mines on the first side) and stalls in the 3 hours after the heal:")
|
|
out.append("")
|
|
out.append(md_table(["honest split", "attacker", "partition min"] + labels, rows_first))
|
|
out.append("")
|
|
# supplementary: more splits, 0% attacker, plus the DAA-retarget and floor variants
|
|
configs2 = configs + [P(denom="active", pmode="cert", daa="full", delay=args.delay),
|
|
P(denom="active", pmode="seen", daa="full", delay=args.delay),
|
|
P(denom="active", pmode="cert", floor=0.8, daa="full", delay=args.delay),
|
|
P(denom="active", pmode="cert", floor=0.85, daa="full", delay=args.delay)]
|
|
labels2 = [p.label() for p in configs2]
|
|
rows = []
|
|
for name, fr in (("50/50", [0.5, 0.5]), ("60/40", [0.6, 0.4]), ("67/33", [0.67, 0.33]), ("80/20", [0.8, 0.2]),
|
|
("33/33/34", [0.33, 0.33, 0.34])):
|
|
for dur in (150, 360):
|
|
rc = [name, dur]
|
|
for p in configs2:
|
|
r = run_partition(args.seed, fr, 0.0, dur, p, post_min=120)
|
|
rc.append("%d; %s" % (r["conflicts"], " / ".join(fm(x) for x in r["side_first_lock"])))
|
|
rows.append(rc)
|
|
out.append("Supplementary, 0% attacker, 150 and 360 min. Cell = conflicting locks; minutes to each side's first lock. "
|
|
"'+daa' = each side retargets to 1 block/s at once (worst case for the presence clock); "
|
|
"'+floor0.80' = active denominator never below 80% of total weight (a lock needs at least 53.3% of total), "
|
|
"'+floor0.85' needs 56.7%.")
|
|
out.append("")
|
|
out.append(md_table(["honest split", "partition min"] + labels2, rows))
|
|
out.append("")
|
|
# presence window sweep, active/cert, 0% attacker
|
|
rows = []
|
|
for presence in (240, 720, 2880):
|
|
for name, fr in (("50/50", [0.5, 0.5]), ("60/40", [0.6, 0.4]), ("33/33/34", [0.33, 0.33, 0.34])):
|
|
dur = {240: 360, 720: 720, 2880: 1500}[presence]
|
|
p = P(denom="active", pmode="cert", presence=presence, delay=args.delay)
|
|
r = run_partition(args.seed, fr, 0.0, dur, p, post_min=120)
|
|
s = min(fr)
|
|
pred = presence * (1.0 - 1.5 * s) / s / 2.0 if s < TWO_THIRDS else None
|
|
rows.append([presence, "%.1f h" % (presence / 120.0), name, dur, r["conflicts"],
|
|
" / ".join(fm(x) for x in r["side_first_lock"]), "%.0f" % pred if pred is not None else "no"])
|
|
out.append("Presence window sweep, active/cert, 0% attacker. Prediction for the smallest side (share s): "
|
|
"first lock after presence x (1 - 1.5 s) / s slots, in minutes = that / 2.")
|
|
out.append("")
|
|
out.append(md_table(["presence (checkpoints)", "presence (hours)", "honest split", "partition min", "conflicts",
|
|
"first lock per side, min", "predicted smallest-side lock, min"], rows))
|
|
return "\n".join(out)
|
|
|
|
|
|
def run_eclipse(seed, dur_h, poisoned, p, pre_min=60, post_h=5):
|
|
rng = np.random.default_rng(seed)
|
|
sim = Sim(p, rng, n_regions=5)
|
|
# shares of TOTAL weight: pool 20%, attacker 34% when poisoned, the rest honest
|
|
others = 0.8 if not poisoned else 0.46
|
|
h = pareto_hashrates(rng, N_HONEST - 1, total=others)
|
|
reg = assign_regions(h, GEOGRAPHY)
|
|
sim.add_keys(h, reg, flaky=True)
|
|
K = int(sim.add_keys([0.2], [3], flaky=False)[0])
|
|
att = None
|
|
if poisoned:
|
|
att = int(sim.add_keys([0.34], [4], flaky=False, equiv=True)[0])
|
|
sim.warm_start()
|
|
sim.init_views(warm=True)
|
|
track = []
|
|
|
|
def snap(s):
|
|
v = [x for x in s.views if 0 in x.regions][0]
|
|
track.append((s.slot, float(min(1.0, v.pcount[K] / p.presence))))
|
|
|
|
sim.run(pre_min * 2, snap=(10, snap))
|
|
t0 = sim.slot
|
|
if poisoned:
|
|
sim.split([[0, 1, 2], [3, 4]])
|
|
else:
|
|
sim.extra_delay[K] = dur_h * 3600.0
|
|
sim.run(int(dur_h * SLOTS_PER_HOUR), snap=(10, snap))
|
|
t_end = sim.slot
|
|
if poisoned:
|
|
sim.heal()
|
|
else:
|
|
sim.extra_delay[K] = 0.0
|
|
sim.run(post_h * SLOTS_PER_HOUR, snap=(10, snap))
|
|
snap(sim)
|
|
recs = sim.recs()
|
|
tr = np.array(track)
|
|
during = tr[(tr[:, 0] >= t0) & (tr[:, 0] <= t_end)]
|
|
after = tr[tr[:, 0] >= t_end]
|
|
res = dict(min_part=float(tr[:, 1].min()), part_at_end=float(during[-1, 1]) if during.shape[0] else 1.0)
|
|
below = tr[(tr[:, 0] >= t0) & (tr[:, 1] < 0.999)]
|
|
res["drop_min"] = None if below.shape[0] == 0 else (below[0, 0] - t0) / 2.0
|
|
rec = after[after[:, 1] >= 0.999]
|
|
res["recover_min"] = None if rec.shape[0] == 0 else (rec[0, 0] - t_end) / 2.0
|
|
res["conflicts"] = len(sim.conflicts)
|
|
res["first_conflict_min"] = (min(c[1] for c in sim.conflicts) - t0) / 2.0 if sim.conflicts else None
|
|
honest_sid = [v for v in [1]] if poisoned else [0]
|
|
res["honest_stalls"] = stalls_between(recs, t0, t_end, sid=(1 if poisoned else 0))
|
|
res["ecl_locks"] = int(((recs[:, 2] == 2) & (recs[:, 3] >= 0) & (recs[:, 0] >= t0) & (recs[:, 0] < t_end)).sum()) if poisoned else 0
|
|
res["post_stalls"] = stalls_between(recs, t_end, sim.slot)
|
|
return res
|
|
|
|
|
|
def scenario_f(args):
|
|
out = ["### F. Eclipse of one pool holding 20% of weight", ""]
|
|
configs = [P(denom="active", pmode="cert", delay=args.delay), P(denom="active", pmode="seen", delay=args.delay),
|
|
P(denom="total", delay=args.delay)]
|
|
rows = []
|
|
for dur in (1, 2, 4):
|
|
for p in configs:
|
|
r = run_eclipse(args.seed, dur, False, p)
|
|
rows.append([dur, p.label(), "%.3f" % r["min_part"], fm(r["drop_min"]), fm(r["recover_min"]), r["conflicts"],
|
|
r["honest_stalls"], r["post_stalls"]])
|
|
out.append("F1. Delayed view: the pool receives every block and vote %s late, votes for the right blocks, late. Participation as the rest of the network computes it." % "D hours")
|
|
out.append("")
|
|
out.append(md_table(["eclipse h", "denominator", "pool participation, minimum", "first drop below 1, min after start",
|
|
"back to 1, min after end", "conflicting locks", "stalls during", "stalls after"], rows))
|
|
out.append("")
|
|
rows = []
|
|
configs2 = configs + [P(denom="active", pmode="cert", floor=0.8, delay=args.delay),
|
|
P(denom="active", pmode="cert", floor=0.85, delay=args.delay)]
|
|
for dur in (1, 2, 4):
|
|
for p in configs2:
|
|
r = run_eclipse(args.seed, dur, True, p)
|
|
rows.append([dur, p.label(), "%.3f" % r["min_part"], fm(r["recover_min"]), r["conflicts"], fm(r["first_conflict_min"]),
|
|
r["ecl_locks"], r["honest_stalls"], r["post_stalls"]])
|
|
out.append("F2. Poisoned view: an attacker holding 34% of weight feeds the pool a private fork for the eclipse, signs both forks, and is stripped at the heal. The pool votes for the attacker's checkpoints. Honest side = the other 46%.")
|
|
out.append("")
|
|
out.append(md_table(["eclipse h", "denominator", "pool participation, minimum (honest view)", "back to 1, min after end",
|
|
"conflicting locks", "first conflict, min after start", "locks on the eclipsed side",
|
|
"honest-side stalls during", "stalls after heal"], rows))
|
|
return "\n".join(out)
|
|
|
|
|
|
def scenario_g(args):
|
|
out = ["### G. Honest doubling overnight at day 60: 1,000 new keys, fresh Pareto draw, same total hashrate as the old 1,000", ""]
|
|
rows_share = []
|
|
rows_lat = []
|
|
ev = []
|
|
for denom in ("active", "total"):
|
|
p = P(denom=denom, delay=args.delay)
|
|
sim, rng, _ = build_honest(p, args.seed)
|
|
h_new = pareto_hashrates(rng, N_HONEST, total=1.0)
|
|
new = sim.add_keys(np.zeros(N_HONEST), assign_regions(h_new, GEOGRAPHY), flaky=True)
|
|
old = np.arange(N_HONEST)
|
|
sim.warm_start()
|
|
sim.init_views(warm=True)
|
|
sim.run(SLOTS_PER_HOUR)
|
|
t_event = sim.slot
|
|
sim.hash[new] = h_new
|
|
sim.set_uptime()
|
|
series = []
|
|
last_23 = None
|
|
for day in range(1, args.days_g + 1):
|
|
sim.run(SLOTS_PER_DAY)
|
|
so = sim.share(old)
|
|
sn = sim.share(new)
|
|
dust_new = int((sim.weight[new] < p.dust).sum())
|
|
series.append((day, so, sn, dust_new))
|
|
if so >= TWO_THIRDS:
|
|
last_23 = day
|
|
recs = sim.recs()
|
|
if denom == "active":
|
|
for d in (1, 5, 10, 15, 20, 21, 25):
|
|
r = [x for x in series if x[0] == d]
|
|
if r:
|
|
rows_share.append(["+%d" % d, pct(r[0][1]), pct(r[0][2]), pct(min(d / 60.0, 0.5)), r[0][3]])
|
|
rows_lat.append(lat_row("%s, day before" % denom, lat_stats(recs, 0, t_event)))
|
|
rows_lat.append(lat_row("%s, days 1 to 5 after" % denom, lat_stats(recs, t_event, t_event + 5 * SLOTS_PER_DAY)))
|
|
rows_lat.append(lat_row("%s, days 5 to %d after" % (denom, args.days_g), lat_stats(recs, t_event + 5 * SLOTS_PER_DAY, None)))
|
|
r45 = next((d for d, so, sn, _ in series if sn >= 0.45), None)
|
|
r49 = next((d for d, so, sn, _ in series if sn >= 0.49), None)
|
|
ev.append([denom, last_23, "not in run" if r45 is None else r45, "not in run" if r49 is None else r49,
|
|
stalls_between(recs, t_event, sim.slot)])
|
|
out.append("Weight shares (active run):")
|
|
out.append("")
|
|
out.append(md_table(["day after doubling", "old cohort", "new cohort", "new cohort formula t/60", "new keys under dust"], rows_share))
|
|
out.append("")
|
|
out.append(md_table(["denominator", "last day old cohort holds 2/3 (locks alone)", "new cohort reaches 45%", "new cohort reaches 49%",
|
|
"stalled checkpoints"], ev))
|
|
out.append("")
|
|
out.append(md_table(LAT_HEADERS, rows_lat))
|
|
return "\n".join(out)
|
|
|
|
|
|
SCENARIOS = {"A": scenario_a, "B": scenario_b, "C": scenario_c, "D": scenario_d, "E": scenario_e, "F": scenario_f, "G": scenario_g}
|
|
|
|
|
|
def main(argv=None):
|
|
ap = argparse.ArgumentParser(description="Igneum finality rule V2 simulation")
|
|
ap.add_argument("--seed", type=int, default=7)
|
|
ap.add_argument("--scenarios", default="A,B,C,D,E,F,G")
|
|
ap.add_argument("--delay", type=float, default=2.0, help="one-way inter-region delay in seconds for the main runs")
|
|
ap.add_argument("--grace", type=float, default=15.0)
|
|
ap.add_argument("--quick", action="store_true", help="shortened runs for development")
|
|
args = ap.parse_args(argv)
|
|
q = args.quick
|
|
args.days_a = 3 if q else 60
|
|
args.days_delay = 1 if q else 3
|
|
args.days_b = 4 if q else 35
|
|
args.hours_c = 3 if q else 6
|
|
args.hours_c_total = 3 if q else 72
|
|
args.days_d35 = 1 if q else 3
|
|
args.days_d50 = 1 if q else 12
|
|
args.days_g = 3 if q else 25
|
|
print("# finality_v2 output")
|
|
print()
|
|
p = P()
|
|
print("seed %d, slot %.0f s, %d blocks per checkpoint, window %d h, presence %d checkpoints, dust %d, quorum 2/3, "
|
|
"inter-region delay %.1f s (intra %.1f s, jitter sigma %.2f), grace %.0f s, uptime %.2f (mean outage %d slots), "
|
|
"uptime %.3f for keys at or above %s of hashrate, honest keys %d Pareto %.1f, geography %s%s" % (
|
|
args.seed, SLOT_S, BLOCKS_PER_CP, WINDOW_HOURS, p.presence, p.dust, args.delay, p.intra, p.jitter,
|
|
args.grace, p.uptime, p.outage, p.uptime_big, pct(p.big_share, 0), N_HONEST, PARETO_SHAPE, "/".join(pct(g, 0) for g in GEOGRAPHY),
|
|
", QUICK" if q else ""))
|
|
print()
|
|
for s in args.scenarios.split(","):
|
|
s = s.strip().upper()
|
|
if s not in SCENARIOS:
|
|
print("unknown scenario %s" % s, file=sys.stderr)
|
|
return 2
|
|
t = time.time()
|
|
print(SCENARIOS[s](args))
|
|
print()
|
|
print("(%s took %.0f s)" % (s, time.time() - t), file=sys.stderr)
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|