cortexm 0.3.0__py3-none-any.whl

cortexm/federation/__init__.py

@@ -0,0 +1,39 @@
+"""Federation — multi-node memory replication and schema aggregation.
+
+Two distinct capabilities (do not conflate them):
+
+1. CRDT REPLICATION (this package's core): conflict-free replicated
+   bi-temporal memory state. Nodes exchange HMAC-signed digest/delta
+   envelopes over any transport; union merge + HLC-stamped OR-set
+   resolution guarantees deterministic convergence with no coordinator,
+   no locks, and no lost retraction semantics.
+
+2. SCHEMA AGGREGATION (``schema_report``): the privacy-preserving
+   Semantic Flywheel — opt-in nodes contribute relation histograms only.
+"""
+
+from cortexm.federation.crdt import (
+    DEFAULT_BUCKETS,
+    FederationState,
+    FactVersion,
+    fact_key,
+)
+from cortexm.federation.fabric import (
+    apply_to_store,
+    export_to_crdt,
+    node_from_store,
+)
+from cortexm.federation.hlc import HLC, parse_stamp
+from cortexm.federation.node import FederationError, FederationNode
+from cortexm.federation.schema_report import (
+    export_schema_report,
+    merge_schema_reports,
+)
+from cortexm.federation.transport import FileTransport, InMemoryMesh
+
+__all__ = [
+    "DEFAULT_BUCKETS", "FederationState", "FactVersion", "fact_key",
+    "HLC", "parse_stamp", "FederationNode", "FederationError",
+    "InMemoryMesh", "FileTransport", "export_to_crdt", "apply_to_store",
+    "node_from_store", "export_schema_report", "merge_schema_reports",
+]

cortexm/federation/crdt.py

@@ -0,0 +1,275 @@
+"""Bi-temporal fact CRDT — conflict-free replicated memory state.
+
+DATA MODEL
+----------
+The symbolic layer is Subject-Relation-Value triples with bi-temporal
+timestamps (valid time + transaction time). Federation replicates it as a
+keyed multi-version register:
+
+* SINGLE_VALUED relations (works_at, lives_in, ...) key on
+  ``(user_id, subject, relation)`` — every historical value is a VERSION in
+  the register; the bi-temporal history is the version set itself.
+* MULTI_VALUED relations (prefers, uses, ...) key on
+  ``(user_id, subject, relation, value)`` — each distinct value is its own
+  register (an OR-set member).
+
+MERGE SEMANTICS (per key)
+-------------------------
+Versions are IMMUTABLE and uniquely stamped by an HLC. Merging two
+replicas is the per-stamp UNION of version sets — commutative,
+associative, idempotent. Resolution for reads is deterministic:
+
+* the winning (live) version is the highest-stamped non-tombstone version
+  whose stamp is greater than the highest tombstone stamp for that key
+  (write-after-retract wins, retract-after-write wins — classic OR-set
+  semantics under a causally-consistent total order);
+* a tombstone causally after a write retracts it;
+* HLC total order means every replica picks the same winner without
+  coordination.
+
+GDPR / PURGE
+------------
+A tombstone with ``purge=True`` is a poison pill: it retracts the key and
+authorises payload GC after the retention window (see ``gc_tombstones``).
+Payloads are dropped; stamps remain until every replica has seen the
+tombstone (digest convergence), so late deltas cannot resurrect purged
+data.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass, field
+
+from cortexm.federation.hlc import HLC, parse_stamp
+
+DEFAULT_BUCKETS = 64
+
+
+def fact_key(user_id: str, subject: str, relation: str,
+             value: str | None = None, single_valued: bool = True) -> str:
+    """Stable CRDT key. SINGLE_VALUED keys omit the value so successive
+    values become versions of one register; MULTI_VALUED keys include it."""
+    parts = [user_id or "default", subject.lower(), relation.lower()]
+    if not single_valued and value is not None:
+        parts.append(value.lower())
+    return "\x1f".join(parts)
+
+
+@dataclass
+class FactVersion:
+    stamp: str                 # HLC string — globally unique version id
+    payload: dict              # serialisable fact fields
+    tombstone: bool = False
+    purge: bool = False        # poison-pill tombstone (GDPR)
+
+    def canonical(self) -> str:
+        return json.dumps({"s": self.stamp, "p": self.payload,
+                           "t": int(self.tombstone), "g": int(self.purge)},
+                          sort_keys=True, separators=(",", ":"))
+
+    def digest(self) -> str:
+        return hashlib.sha256(self.canonical().encode()).hexdigest()[:16]
+
+
+@dataclass
+class BucketStat:
+    n: int = 0
+    max_stamp: str = ""
+    xor: int = 0
+
+
+@dataclass
+class FederationState:
+    """The CRDT: key -> stamp -> version. Pure data; all operations are
+    functions so merge logic is trivially testable."""
+    node_id: str
+    buckets: int = DEFAULT_BUCKETS
+    _versions: dict[str, dict[str, FactVersion]] = field(default_factory=dict)
+
+    # ---------------------------------------------------------------- write
+    def put(self, key: str, payload: dict, clock: HLC,
+            tombstone: bool = False, purge: bool = False,
+            stamp: str | None = None) -> FactVersion:
+        st = stamp or clock.tick()
+        v = FactVersion(stamp=st, payload=payload, tombstone=tombstone,
+                        purge=purge)
+        self._versions.setdefault(key, {})[st] = v
+        return v
+
+    # ---------------------------------------------------------------- merge
+    def merge_versions(self, key: str, versions: dict[str, dict]) -> int:
+        """Union-merge remote versions into a key. Returns #applied."""
+        slot = self._versions.setdefault(key, {})
+        applied = 0
+        for stamp, raw in versions.items():
+            if stamp not in slot:
+                slot[stamp] = FactVersion(
+                    stamp=stamp,
+                    payload=raw.get("payload", {}),
+                    tombstone=bool(raw.get("tombstone", False)),
+                    purge=bool(raw.get("purge", False)))
+                applied += 1
+        return applied
+
+    def apply_delta(self, delta: dict) -> int:
+        """Idempotent: re-applying the same delta changes nothing."""
+        applied = 0
+        for key, versions in delta.get("versions", {}).items():
+            applied += self.merge_versions(key, versions)
+        return applied
+
+    # ---------------------------------------------------------------- read
+    def keys(self) -> list[str]:
+        return list(self._versions)
+
+    def all_versions(self, key: str) -> list[FactVersion]:
+        return sorted(self._versions.get(key, {}).values(),
+                      key=lambda v: v.stamp)
+
+    def live_versions(self, key: str) -> list[FactVersion]:
+        """OR-set resolution: drop versions causally covered by a tombstone.
+
+        A tombstone covers every version with a strictly smaller stamp. A
+        purge tombstone additionally covers versions with LARGER stamps
+        (poison pill — nothing may resurrect a purged key except a write
+        that causally follows the purge, i.e. stamps issued after the
+        purge was *received* are still allowed via the purge's own stamp
+        being smaller... we keep it strict: purge kills everything with a
+        different stamp than itself).
+        """
+        vs = self._versions.get(key, {})
+        if not vs:
+            return []
+        tomb_stamps = [v.stamp for v in vs.values() if v.tombstone]
+        purge_stamps = [v.stamp for v in vs.values() if v.purge]
+        max_tomb = max(tomb_stamps) if tomb_stamps else ""
+        out = []
+        for v in vs.values():
+            if v.tombstone:
+                continue
+            if v.stamp < max_tomb:
+                continue                      # retracted
+            if purge_stamps and v.stamp not in purge_stamps:
+                continue                      # purged
+            out.append(v)
+        return sorted(out, key=lambda v: v.stamp)
+
+    def winner(self, key: str) -> FactVersion | None:
+        live = self.live_versions(key)
+        return live[-1] if live else None
+
+    def value_history(self, key: str) -> list[FactVersion]:
+        """All live versions ordered by valid_from — the bi-temporal
+        timeline for a SINGLE_VALUED key."""
+        live = self.live_versions(key)
+
+        def vf(v):
+            return v.payload.get("valid_from") or ""
+
+        return sorted(live, key=vf)
+
+    # ------------------------------------------------------------- digests
+    def bucket_of(self, key: str) -> int:
+        h = int(hashlib.blake2b(key.encode(), digest_size=8).hexdigest(), 16)
+        return h % self.buckets
+
+    def digest(self) -> dict:
+        """Per-bucket (count, max_stamp, xor-fold) vector. Two replicas
+        with identical digests are (hash-collision aside) identical."""
+        stats: dict[int, BucketStat] = {}
+        for key, versions in self._versions.items():
+            b = self.bucket_of(key)
+            st = stats.setdefault(b, BucketStat())
+            for v in versions.values():
+                st.n += 1
+                if v.stamp > st.max_stamp:
+                    st.max_stamp = v.stamp
+                st.xor ^= int(v.digest(), 16)
+        return {str(b): [st.n, st.max_stamp, f"{st.xor:016x}"]
+                for b, st in sorted(stats.items())}
+
+    def delta_for(self, their_digest: dict) -> dict:
+        """Ship every version of every bucket where the digests differ."""
+        mine = self.digest()
+        diverged = []
+        for b, stat in mine.items():
+            if their_digest.get(b) != stat:
+                diverged.append(int(b))
+        # buckets they have that I don't (still ship mine — union merge)
+        for b in their_digest:
+            if b not in mine:
+                diverged.append(int(b))
+        versions: dict[str, dict[str, dict]] = {}
+        for key, vs in self._versions.items():
+            if self.bucket_of(key) in diverged:
+                versions[key] = {st: {"payload": v.payload,
+                                      "tombstone": v.tombstone,
+                                      "purge": v.purge}
+                                 for st, v in vs.items()}
+        return {"buckets": sorted(set(diverged)), "versions": versions}
+
+    # ------------------------------------------------------------- gc / size
+    def gc_tombstones(self, older_than_stamp: str) -> dict:
+        """Drop tombstoned payloads past the retention watermark.
+
+        Safe only once every replica has seen the tombstone (digest
+        convergence); the caller enforces that. Stamps of purged keys are
+        retained as empty tombstones so late deltas merge to the same
+        (retracted) resolution instead of resurrecting data.
+        """
+        removed = {"versions": 0, "payloads": 0}
+        for key, vs in list(self._versions.items()):
+            for st, v in list(vs.items()):
+                if v.tombstone and st < older_than_stamp:
+                    if v.payload:
+                        v.payload = {}
+                        removed["payloads"] += 1
+                    removed["versions"] += 1
+        return removed
+
+    def stats(self) -> dict:
+        n_versions = sum(len(v) for v in self._versions.values())
+        n_keys = len(self._versions)
+        n_tomb = sum(1 for vs in self._versions.values()
+                     for v in vs.values() if v.tombstone)
+        return {"keys": n_keys, "versions": n_versions,
+                "tombstones": n_tomb}
+
+    # ---------------------------------------------------------- canonicalise
+    def canonical_bytes(self) -> bytes:
+        """Byte-exact canonical form — two converged replicas produce
+        IDENTICAL bytes. This is the convergence oracle used by tests."""
+        out = {}
+        for key in sorted(self._versions):
+            vs = self._versions[key]
+            out[key] = {st: vs[st].canonical()
+                        for st in sorted(vs)}
+        return json.dumps(out, sort_keys=True,
+                          separators=(",", ":")).encode()
+
+    # ------------------------------------------------------------ snapshot
+    def snapshot(self) -> dict:
+        return {"node_id": self.node_id, "buckets": self.buckets,
+                "versions": {k: {st: {"payload": v.payload,
+                                       "tombstone": v.tombstone,
+                                       "purge": v.purge}
+                                  for st, v in vs.items()}
+                             for k, vs in self._versions.items()}}
+
+    @classmethod
+    def from_snapshot(cls, d: dict) -> "FederationState":
+        st = cls(node_id=d["node_id"], buckets=d.get("buckets",
+                                                     DEFAULT_BUCKETS))
+        for key, vs in d.get("versions", {}).items():
+            st._versions[key] = {stamp: FactVersion(
+                stamp=stamp, payload=raw.get("payload", {}),
+                tombstone=bool(raw.get("tombstone")),
+                purge=bool(raw.get("purge"))) for stamp, raw in vs.items()}
+        return st
+
+
+def stamp_sort_key(stamp: str):
+    wall, count, node = parse_stamp(stamp)
+    return (wall, count, node)

cortexm/federation/fabric.py

@@ -0,0 +1,109 @@
+"""Bridge the local TraceStore (symbolic layer) into the federated CRDT.
+
+Direction 1 — ``export_to_crdt``: every stored fact (active AND historical)
+becomes an immutable CRDT version under its key. SINGLE_VALUED relations
+collapse into one versioned register per (user, subject, relation);
+MULTI_VALUED facts get one register per distinct value.
+
+Direction 2 — ``apply_to_store``: merge a node's converged state back into
+a fabric: unknown fact ids are inserted, known ids are updated field-wise
+(stamps guarantee newest-wins deterministically). The fabric's own truth
+maintenance (SUPERSEDE edges) is NOT replayed — the CRDT versions already
+carry the bi-temporal windows, so the store receives resolved history.
+
+Caveat (honest scope): retrieval-side caches (VSA palace projections) must
+be rebuilt after applying remote deltas — ``apply_to_store`` returns the
+number of store writes so callers can decide when to reproject.
+"""
+
+from __future__ import annotations
+
+from cortexm.federation.crdt import (
+    FederationState,
+    fact_key,
+)
+from cortexm.federation.hlc import HLC
+from cortexm.federation.node import FederationNode
+from cortexm.trace.fact import Fact, SINGLE_VALUED
+
+_FED_FIELDS = (
+    "subject", "relation", "value", "valid_from", "valid_to",
+    "confidence", "user_id", "agent_id", "run_id", "memory_type",
+    "source_hash", "source_id", "provenance",
+)
+
+
+def _fact_payload(f: Fact) -> dict:
+    return {k: getattr(f, k) for k in _FED_FIELDS}
+
+
+def export_to_crdt(store, node: FederationNode,
+                   user_id: str | None = None) -> int:
+    """Push the store's facts into the node's CRDT state."""
+    facts = store.query_facts(user_id=user_id)   # active + historical
+    n = 0
+    for f in facts:
+        single = f.relation in SINGLE_VALUED
+        key = fact_key(f.user_id, f.subject, f.relation,
+                       value=f.value, single_valued=single)
+        payload = _fact_payload(f)
+        payload["fact_id"] = f.id
+        if not f.is_active:
+            # inactive fact -> tombstone version carrying its own payload
+            # so history queries can still see WHAT was retracted
+            node.state.put(key, payload, node.clock, tombstone=True)
+        else:
+            node.state.put(key, payload, node.clock)
+        n += 1
+    return n
+
+
+def apply_to_store(node: FederationNode, store) -> dict:
+    """Pull the node's converged CRDT state into a store."""
+    inserted = updated = retracted = 0
+    for key in node.state.keys():
+        live = node.state.value_history(key)
+        for v in live:
+            payload = v.payload
+            fact_id = payload.get("fact_id")
+            required = ("subject", "relation", "value", "valid_from")
+            if not fact_id or any(k not in payload for k in required):
+                continue          # incomplete version — not fabric-shaped
+            existing = store.get_fact(fact_id)
+            if existing is None:
+                f = Fact(id=fact_id, **{k: payload[k] for k in _FED_FIELDS
+                                        if k in payload})
+                store.insert_fact(f)
+                inserted += 1
+            else:
+                dirty = {k: payload[k] for k in _FED_FIELDS
+                         if k in payload and getattr(existing, k) !=
+                         payload[k]}
+                if dirty:
+                    store.update_fact(fact_id, **dirty)
+                    updated += 1
+        # retracted keys: mirror tombstones into the store
+        all_v = node.state.all_versions(key)
+        tombstoned_ids = {v.payload.get("fact_id") for v in all_v
+                          if v.tombstone and v.payload}
+        for fid in tombstoned_ids:
+            if fid and store.get_fact(fid) is not None:
+                f = store.get_fact(fid)
+                if f.is_active:
+                    store.update_fact(fid, is_active=False)
+                    retracted += 1
+    return {"inserted": inserted, "updated": updated,
+            "retracted": retracted}
+
+
+def node_from_store(node_id: str, store, members: list[str] | None = None,
+                    federation_key: str = "default-fed-key",
+                    user_id: str | None = None) -> FederationNode:
+    node = FederationNode(node_id, members=members,
+                          federation_key=federation_key)
+    export_to_crdt(store, node, user_id=user_id)
+    return node
+
+
+__all__ = ["export_to_crdt", "apply_to_store", "node_from_store",
+           "FederationState", "FederationNode", "HLC", "fact_key"]

cortexm/federation/hlc.py

@@ -0,0 +1,80 @@
+"""Hybrid Logical Clock — causality-consistent total order for federation.
+
+Wall-clock milliseconds give rough ordering; a counter breaks same-ms ties
+and absorbs clock skew via the receive rule (max of local and remote);
+node_id makes the order total and deterministic on every replica.
+
+String form ``wall.counter.node`` sorts lexicographically EXACTLY like the
+tuple (wall is zero-padded), so CRDT stamps can be compared as plain
+strings everywhere downstream.
+"""
+
+from __future__ import annotations
+
+import threading
+
+
+def _pad(wall_ms: int) -> str:
+    return f"{wall_ms:019d}"
+
+
+class HLC:
+    """One clock per node. Thread-safe."""
+
+    __slots__ = ("node_id", "_wall", "_count", "_lock")
+
+    def __init__(self, node_id: str, wall_ms: int = 0, count: int = 0) -> None:
+        self.node_id = node_id
+        self._wall = wall_ms
+        self._count = count
+        self._lock = threading.Lock()
+
+    # -- local event ------------------------------------------------------
+    def tick(self, now_ms: int | None = None) -> str:
+        import time
+        now = int(time.time() * 1000) if now_ms is None else now_ms
+        with self._lock:
+            if now > self._wall:
+                self._wall, self._count = now, 0
+            else:
+                self._count += 1
+            return self._stamp()
+
+    # -- remote event -----------------------------------------------------
+    def receive(self, remote_stamp: str) -> str:
+        wall, count, _node = parse_stamp(remote_stamp)
+        import time
+        now = int(time.time() * 1000)
+        with self._lock:
+            if now > self._wall and now > wall:
+                self._wall, self._count = now, 0
+            elif wall > self._wall:
+                self._wall, self._count = wall, count + 1
+            else:
+                self._count = max(self._count, count) + 1
+            return self._stamp()
+
+    def now(self) -> str:
+        return self.tick()
+
+    def peek(self) -> str:
+        with self._lock:
+            return self._stamp()
+
+    def _stamp(self) -> str:
+        return f"{_pad(self._wall)}.{self._count:06d}.{self.node_id}"
+
+    # -- persistence ------------------------------------------------------
+    def state(self) -> dict:
+        with self._lock:
+            return {"node_id": self.node_id, "wall": self._wall,
+                    "count": self._count}
+
+    @classmethod
+    def from_state(cls, d: dict) -> "HLC":
+        return cls(d["node_id"], d["wall"], d["count"])
+
+
+def parse_stamp(stamp: str) -> tuple[int, int, str]:
+    wall_s, count_s, node = stamp.split(".", 2)
+    return int(wall_s), int(count_s), node

cortexm/federation/node.py

@@ -0,0 +1,145 @@
+"""FederationNode — identity, delta signing/verification, anti-entropy sync.
+
+Threat model (documented honestly):
+* members share a symmetric federation key (HMAC-SHA256); every delta is
+  signed and the sender must be a known member id;
+* signatures authenticate origin + integrity, NOT freshness — replaying an
+  old delta is harmless (merge is idempotent) but replay of a *valid*
+  signed delta is possible; monotonic HLC stamps bound how far a replayed
+  delta can move state;
+* this is transport-agnostic: deltas are JSON envelopes handed to whatever
+  transport is configured (in-memory mesh for tests, files for offline
+  federation, HTTP/TCP in production).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+
+from cortexm.federation.crdt import FederationState
+from cortexm.federation.hlc import HLC
+
+
+def _canonical_env(env: dict) -> bytes:
+    return json.dumps(env, sort_keys=True, separators=(",", ":")).encode()
+
+
+def sign_envelope(env: dict, key: str) -> str:
+    return hmac.new(key.encode(), _canonical_env(env),
+                    hashlib.sha256).hexdigest()
+
+
+class FederationError(Exception):
+    pass
+
+
+class FederationNode:
+    """One replica of the federated memory state."""
+
+    def __init__(self, node_id: str, members: list[str] | None = None,
+                 federation_key: str = "default-fed-key",
+                 buckets: int = 64,
+                 state: FederationState | None = None) -> None:
+        self.node_id = node_id
+        self.members = set(members or [node_id])
+        self.members.add(node_id)
+        self.federation_key = federation_key
+        self.clock = HLC(node_id)
+        self.state = state or FederationState(node_id, buckets)
+        self.bytes_sent = 0
+        self.bytes_received = 0
+        self.syncs = 0
+
+    # ------------------------------------------------------------ writes
+    def put_fact(self, key: str, payload: dict) -> str:
+        return self.state.put(key, payload, self.clock)
+
+    def retract(self, key: str, purge: bool = False) -> str:
+        return self.state.put(key, {}, self.clock,
+                              tombstone=True, purge=purge)
+
+    # ------------------------------------------------------------ digests
+    def digest_envelope(self) -> dict:
+        env = {"type": "digest", "from": self.node_id,
+               "clock": self.clock.now(),
+               "digest": self.state.digest()}
+        env["sig"] = sign_envelope({k: v for k, v in env.items()},
+                                   self.federation_key)
+        return env
+
+    # ------------------------------------------------------------ deltas
+    def delta_envelope_for(self, their_digest_env: dict) -> dict:
+        self._verify(their_digest_env, expected_type="digest")
+        # absorb sender's clock — keeps our stamps causally after theirs
+        self.clock.receive(their_digest_env["clock"])
+        their_digest = their_digest_env["digest"]
+        delta = self.state.delta_for(their_digest)
+        env = {"type": "delta", "from": self.node_id,
+               "to": their_digest_env["from"],
+               "clock": self.clock.now(),
+               "delta": delta}
+        env["sig"] = sign_envelope({k: v for k, v in env.items()},
+                                   self.federation_key)
+        return env
+
+    def apply_delta_envelope(self, env: dict) -> int:
+        self._verify(env, expected_type="delta")
+        if env.get("to") not in (None, self.node_id):
+            raise FederationError(f"delta addressed to {env.get('to')}")
+        self.clock.receive(env["clock"])
+        n = self.state.apply_delta(env["delta"])
+        return n
+
+    def _verify(self, env: dict, expected_type: str) -> None:
+        if env.get("type") != expected_type:
+            raise FederationError(f"expected {expected_type}, got "
+                                  f"{env.get('type')}")
+        sender = env.get("from")
+        if sender not in self.members:
+            raise FederationError(f"unknown sender: {sender}")
+        sig = env.pop("sig", None)
+        if sig is None:
+            raise FederationError("unsigned envelope rejected")
+        expect = sign_envelope(env, self.federation_key)
+        if not hmac.compare_digest(sig, expect):
+            raise FederationError(f"bad signature from {sender}")
+        env["sig"] = sig  # restore
+
+    # ------------------------------------------------------------ sync
+    def sync_with(self, other: "FederationNode") -> dict:
+        """Two-way anti-entropy: digest exchange then both-direction deltas.
+
+        Order (A=self, B=other):
+          A --digest--> B ; B --delta(for A)--> A ; A applies
+          B --digest--> A ; A --delta(for B)--> B ; B applies
+        After both half-rounds the states converge (union merge + OR-set
+        resolution is commutative). Returns a small accounting dict.
+        """
+        a_bytes = b_bytes = 0
+
+        d1 = self.digest_envelope()
+        delta1 = other.delta_envelope_for(d1)
+        a_bytes += len(json.dumps(d1))
+        b_bytes += len(json.dumps(delta1))
+        self.bytes_received += len(json.dumps(delta1))
+        other.bytes_sent += len(json.dumps(delta1))
+        applied_self = self.apply_delta_envelope(delta1)
+
+        d2 = other.digest_envelope()
+        delta2 = self.delta_envelope_for(d2)
+        b_bytes += len(json.dumps(d2))
+        a_bytes += len(json.dumps(delta2))
+        other.bytes_received += len(json.dumps(delta2))
+        self.bytes_sent += len(json.dumps(delta2))
+        applied_other = other.apply_delta_envelope(delta2)
+
+        self.syncs += 1
+        other.syncs += 1
+        return {"a_sent_bytes": a_bytes, "b_sent_bytes": b_bytes,
+                "a_applied": applied_self, "b_applied": applied_other}
+
+    def converged_with(self, other: "FederationNode") -> bool:
+        return (self.state.canonical_bytes() ==
+                other.state.canonical_bytes())