from __future__ import annotations import hashlib import json import time from dataclasses import asdict, dataclass, field from borderland import Campaign from borderland.domain import canonical from borderland.replay import source_hash from borderland_eval.context import actor_view from borderland_verify.causal_reference import CausalReference def digest(value): return hashlib.sha256(canonical(value).encode()).hexdigest() class BoundExceeded(RuntimeError): pass @dataclass class Counter: limit: int seconds: float started: float = field(default_factory=time.monotonic) used: int = 0 current_commands: list = field(default_factory=list) def check(self): if self.used >= self.limit: raise BoundExceeded('action_cap') if time.monotonic() - self.started >= self.seconds: raise BoundExceeded('wall_cap') @dataclass(frozen=True) class PublicRecord: id: str subject: str supersedes: str | None applies_channel: str | None applies_bit: int | None packet: str @dataclass(frozen=True) class PublicEvidence: measurements: tuple[tuple[str, int, int], ...] records: tuple[PublicRecord, ...] history: tuple[str, ...] @property def services(self): return tuple(sorted({record.subject for record in self.records})) def candidates(self, service): return tuple(record for record in self.records if record.subject == service) def bit(self, channel): return next(bit for name, bit, _ in self.measurements if name == channel) @dataclass class Execution: campaign: Campaign counter: Counter commands: list = field(default_factory=list) trial_receipt: dict = field(default_factory=dict) def __post_init__(self): self.counter.current_commands = self.commands def command(self, kind, payload, role, local_limit=None): self.counter.check() if local_limit is not None and len(self.commands) >= local_limit: raise BoundExceeded('prefix_cap') transition = (self.campaign.step(payload) if kind == 'action' else self.campaign.replace_notebook(payload)) self.counter.used += 1 self.commands.append(dict(kind=kind, input=payload, role=role, public_digest=digest(actor_view(transition)), transition_digest=digest(transition.to_dict()))) if transition.error: raise ValueError('engine rejected command: ' + transition.error.code) return transition @dataclass(frozen=True) class ArchiveCase: root: int seed: int engine_hash: str prefix: tuple[str, ...] evidence: PublicEvidence public_digest: str @classmethod def acquire(cls, root, parity, counter): if type(root) is not int or root < 0 or parity not in (0, 1): raise ValueError('invalid root or parity') execution = Execution(Campaign.generated(2 * root + parity, generation_version=3, memory_profile='commissioning', archive_workload='standard', notebook_bytes=768), counter) transition = execution.campaign.observe() reference = CausalReference() measurements = {} transit = None records = {} history = [] def ingest(t): nonlocal transit observation = actor_view(t)['observation'] board = observation['board'] if observation['phase'] == 1: values = measurements.setdefault(board['channel'], [None, None]) if board['live_sensor'] is not None: values[0] = board['live_sensor'] ^ (board['latch'] & 1) if board['phase_mark'] is not None: values[1] = (board['phase_mark'] - board['latch']) % 4 if observation['phase'] == 2 and board['transit_plate'] is not None: transit = board['transit_plate'] if observation['phase'] == 3 and board['records']: history.append(canonical(actor_view(t))) for packet in board['records']: records[packet['id']] = PublicRecord( packet['id'], packet['subject'], packet['supersedes'], packet['applies_channel'], packet['applies_bit'], canonical(packet)) ingest(transition) while int(transition.observation.phase) < 3 and not transition.done: action = reference.choose(transition) transition = execution.command('action', action.to_dict(), 'public_reference_prefix', 240) ingest(transition) if int(transition.observation.phase) != 3: raise ValueError('prefix did not reach Archive') slots = actor_view(transition)['observation']['board']['slots'] for slot in slots: for page in range(3): payload = dict(tag='open_scroll', arguments=dict(slot=slot)) if page == 0 else dict(tag='advance_page', arguments={}) transition = execution.command('action', payload, 'public_archive_reading', 240) ingest(transition) if len(slots) != 8 or len(records) != 24 or transit is None or any(None in values for values in measurements.values()): raise ValueError('incomplete public acquisition') evidence = PublicEvidence(tuple((key, *values) for key, values in measurements.items()), tuple(records[key] for key in sorted(records)), tuple(history)) note = canonical(dict(m=[(name, str(bit), phase) for name, bit, phase in evidence.measurements], t=transit)) transition = execution.command('note', note, 'supplied_public_measurement_note', 240) case = cls(root, 2 * root + parity, source_hash(), tuple(canonical(command) for command in execution.commands), evidence, digest(actor_view(transition))) return case, execution def reconstruct(self, counter): if self.engine_hash != source_hash(): raise ValueError('case source mismatch') execution = Execution(Campaign.generated(self.seed, generation_version=3, memory_profile='commissioning', archive_workload='standard', notebook_bytes=768), counter) for encoded in self.prefix: command = json.loads(encoded) transition = execution.command(command['kind'], command['input'], command['role'], 240) if execution.commands[-1] != command: raise ValueError('prefix replay mismatch') if digest(actor_view(transition)) != self.public_digest: raise ValueError('prefix final public mismatch') return execution def recipe(self): return asdict(self) def actor_packet(execution, evidence): return dict(current=actor_view(execution.campaign.observe()), history=[json.loads(value) for value in evidence.history]) def surviving_projection(packet): value = json.loads(canonical(packet)) value['current']['observation']['notebook'].pop('text') return value def require_twins(left, right): if canonical(surviving_projection(left)) != canonical(surviving_projection(right)): raise ValueError('complete surviving actor projection mismatch') def physical_projection(execution): value = asdict(execution.campaign._state) value.pop('notebook') value.pop('revision') return value