astreum 0.3.16__py3-none-any.whl → 0.3.48__py3-none-any.whl

astreum/verification/__init__.py

@@ -0,0 +1,4 @@
+from .worker import make_verify_worker
+from .node import verify_blockchain
+
+__all__ = ["make_verify_worker", "verify_blockchain"]

astreum/{consensus/workers/discovery.py → verification/discover.py}

@@ -14,7 +14,7 @@ def make_discovery_worker(node: Any):
 
     def _discovery_worker() -> None:
         node.logger.info("Discovery worker started")
-        stop = node._validation_stop_event
+        stop = node._verify_stop_event
         while not stop.is_set():
             try:
                 peers = getattr(node, "peers", None)

astreum/verification/node.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import threading
+from queue import Queue
+from typing import Any
+
+from astreum.communication.node import connect_node
+
+from .discover import make_discovery_worker
+from .worker import make_verify_worker
+
+
+def verify_blockchain(self: Any):
+    """Ensure verification primitives exist, then start discovery and verify workers."""
+    connect_node(self)
+
+    self._validation_verify_queue = Queue()
+
+    self.chains = {}
+    self.forks = {}
+    self.logger.debug(
+        "Consensus maps ready for verification (chains=%s, forks=%s)",
+        len(self.chains),
+        len(self.forks),
+    )
+
+    stop_event = getattr(self, "_verify_stop_event", None)
+    if stop_event is None:
+        stop_event = threading.Event()
+        self._verify_stop_event = stop_event
+    stop_event.clear()
+
+    discovery_thread = getattr(self, "latest_block_discovery_thread", None)
+    if discovery_thread is not None and discovery_thread.is_alive():
+        self.logger.debug("Consensus discovery thread already running")
+    else:
+        discovery_worker = make_discovery_worker(self)
+        discovery_thread = threading.Thread(
+            target=discovery_worker,
+            daemon=True,
+            name="latest-block-discovery",
+        )
+        self.latest_block_discovery_thread = discovery_thread
+        discovery_thread.start()
+        self.logger.info(
+            "Started latest-block discovery thread (%s)", discovery_thread.name
+        )
+
+    verify_thread = getattr(self, "verify_thread", None)
+    if verify_thread is not None and verify_thread.is_alive():
+        self.logger.debug("Consensus verify thread already running")
+        return verify_thread
+
+    verify_worker = make_verify_worker(self)
+    verify_thread = threading.Thread(
+        target=verify_worker, daemon=True, name="verify-worker"
+    )
+    self.verify_thread = verify_thread
+    verify_thread.start()
+    self.logger.info("Started verify thread (%s)", verify_thread.name)
+    return verify_thread

astreum/verification/worker.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+import time
+from queue import Empty
+from typing import Any, Optional, Set, Tuple
+
+from astreum.validation.models.fork import Fork
+from astreum.validation.models.block import Block
+
+
+def _process_peers_latest_block(
+    node: Any, latest_block_hash: bytes, peer_ids: Set[Any]
+) -> None:
+    """Assign peers to the fork that matches their reported head."""
+    node.logger.debug(
+        "Processing %d peers reporting block %s",
+        len(peer_ids),
+        latest_block_hash.hex()
+        if isinstance(latest_block_hash, (bytes, bytearray))
+        else latest_block_hash,
+    )
+    new_fork = Fork(head=latest_block_hash)
+
+    new_fork.verify(node)
+
+    if new_fork.validated_upto and new_fork.validated_upto in node.forks:
+        ref = node.forks[new_fork.validated_upto]
+        if getattr(ref, "malicious_block_hash", None):
+            node.logger.warning(
+                "Skipping fork from block %s referencing malicious fork %s",
+                latest_block_hash.hex()
+                if isinstance(latest_block_hash, (bytes, bytearray))
+                else latest_block_hash,
+                new_fork.validated_upto.hex()
+                if isinstance(new_fork.validated_upto, (bytes, bytearray))
+                else new_fork.validated_upto,
+            )
+            return
+        new_fork.root = ref.root
+        new_fork.validated_upto = ref.validated_upto
+        new_fork.chain_fork_position = ref.chain_fork_position
+
+    for peer_id in peer_ids:
+        new_fork.add_peer(peer_id)
+        for head, fork in list(node.forks.items()):
+            if head != latest_block_hash:
+                fork.remove_peer(peer_id)
+
+    node.forks[latest_block_hash] = new_fork
+    node.logger.debug(
+        "Fork %s now has %d peers (total forks %d)",
+        latest_block_hash.hex()
+        if isinstance(latest_block_hash, (bytes, bytearray))
+        else latest_block_hash,
+        len(new_fork.peers),
+        len(node.forks),
+    )
+
+
+def _select_best_fork_head(node: Any) -> Optional[Tuple[bytes, Block, int]]:
+    forks = getattr(node, "forks", None)
+    if not isinstance(forks, dict) or not forks:
+        return None
+
+    config = getattr(node, "config", {}) or {}
+    try:
+        max_stale = int(config.get("verification_max_stale_seconds", 10))
+    except (TypeError, ValueError):
+        max_stale = 10
+    try:
+        max_future = int(config.get("verification_max_future_skew", 2))
+    except (TypeError, ValueError):
+        max_future = 2
+
+    now = int(time.time())
+    current_head = getattr(node, "latest_block_hash", None)
+
+    best_head: Optional[bytes] = None
+    best_block: Optional[Block] = None
+    best_height: int = -1
+
+    for head, fork in list(forks.items()):
+        if getattr(fork, "malicious_block_hash", None):
+            continue
+        if not getattr(fork, "validated_upto", None):
+            continue
+        if not getattr(fork, "peers", None):
+            continue
+        if not isinstance(head, (bytes, bytearray)):
+            continue
+
+        try:
+            block = Block.from_atom(node, head)
+        except Exception:
+            continue
+
+        ts = getattr(block, "timestamp", None)
+        if ts is None:
+            continue
+        ts_int = int(ts)
+        if max_stale >= 0 and (now - ts_int) > max_stale:
+            continue
+        if max_future >= 0 and (ts_int - now) > max_future:
+            continue
+
+        height = int(getattr(block, "number", 0) or 0)
+        if height > best_height:
+            best_head = bytes(head)
+            best_block = block
+            best_height = height
+            continue
+        if height == best_height:
+            if current_head == head:
+                best_head = bytes(head)
+                best_block = block
+                best_height = height
+            elif current_head != best_head and best_head is not None:
+                if bytes(head) < bytes(best_head):
+                    best_head = bytes(head)
+                    best_block = block
+                    best_height = height
+
+    if best_head is None or best_block is None:
+        return None
+    return best_head, best_block, best_height
+
+
+def make_verify_worker(node: Any):
+    """Build the verify worker bound to the given node."""
+
+    def _verify_worker() -> None:
+        node.logger.info("Verify worker started")
+        stop = node._verify_stop_event
+        while not stop.is_set():
+            batch: list[tuple[bytes, Set[Any]]] = []
+            try:
+                while True:
+                    latest_b, peers = node._validation_verify_queue.get_nowait()
+                    batch.append((latest_b, peers))
+            except Empty:
+                pass
+
+            if not batch:
+                node.logger.debug("Verify queue empty; sleeping")
+                time.sleep(0.1)
+                continue
+
+            batch.sort(key=lambda item: len(item[1]), reverse=True)
+
+            for latest_b, peers in batch:
+                try:
+                    _process_peers_latest_block(node, latest_b, peers)
+                    node.logger.debug(
+                        "Updated forks from block %s for %d peers",
+                        latest_b.hex()
+                        if isinstance(latest_b, (bytes, bytearray))
+                        else latest_b,
+                        len(peers),
+                    )
+                except Exception:
+                    latest_hex = (
+                        latest_b.hex()
+                        if isinstance(latest_b, (bytes, bytearray))
+                        else latest_b
+                    )
+                    node.logger.exception(
+                        "Failed processing verification batch for %s", latest_hex
+                    )
+
+            selected = _select_best_fork_head(node)
+            if selected is not None:
+                selected_head, selected_block, selected_height = selected
+                if getattr(node, "latest_block_hash", None) != selected_head:
+                    node.latest_block_hash = selected_head
+                    node.latest_block = selected_block
+                    node.logger.info(
+                        "Selected verified head %s (height=%s)",
+                        selected_head.hex(),
+                        selected_height,
+                    )
+        node.logger.info("Verify worker stopped")
+
+    return _verify_worker

{astreum-0.3.16.dist-info → astreum-0.3.48.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.3.16
+Version: 0.3.48
 Summary: Python library to interact with the Astreum blockchain and its virtual machine.
 Author-email: "Roy R. O. Okello" <roy@stelar.xyz>
 Project-URL: Homepage, https://github.com/astreum/lib-py
@@ -33,18 +33,31 @@ When initializing an `astreum.Node`, pass a dictionary with any of the options b
 | `hot_storage_limit`         | int        | `1073741824`   | Maximum bytes kept in the hot cache before new atoms are skipped (1 GiB).                                                                                                         |
 | `cold_storage_limit`        | int        | `10737418240`  | Cold storage write threshold (10 GiB by default); set to `0` to skip the limit.                                                                                                   |
 | `cold_storage_path`         | string     | `None`         | Directory where persisted atoms live; Astreum creates it on startup and skips cold storage when unset.                                                                            |
-| `logging_retention`         | int        | `90`           | Number of days to keep rotated log files (daily gzip).                                                                                                                           |
+| `atom_fetch_interval`       | float      | `0.25`         | Poll interval (seconds) while waiting for missing atoms in `get_atom_list_from_storage`; `0` disables waiting.                                                                    |
+| `atom_fetch_retries`        | int        | `8`            | Number of poll attempts for missing atoms; max wait is roughly `interval * retries`, `0` disables waiting.                                                                        |
+| `logging_retention_days`    | int        | `90`           | Number of days to keep rotated log files (daily gzip).                                                                                                                           |
+| `chain_id`                  | int        | `0`            | Chain identifier used for validation (0 = test, 1 = main).                                                                                                                        |
 | `verbose`                   | bool       | `False`        | When **True**, also mirror JSON logs to stdout with a human-readable format.                                                                                                     |
 
-### Networking
+### Communication
 
 | Parameter                | Type        | Default               | Description                                                                                             |
 | ------------------------ | ----------- | --------------------- | ------------------------------------------------------------------------------------------------------- |
 | `relay_secret_key`       | hex string  | Auto-generated        | X25519 private key used for the relay route; a new keypair is created when this field is omitted.        |
 | `validation_secret_key`  | hex string  | `None`                | Optional Ed25519 key that lets the node join the validation route; leave blank to opt out of validation. |
 | `use_ipv6`               | bool        | `False`               | Bind the incoming/outgoing sockets on IPv6 (the OS still listens on IPv4 if a peer speaks both).         |
-| `incoming_port`          | int         | `7373`                | UDP port the relay binds to; pass `0` or omit to let the OS pick an ephemeral port.                       |
-| `bootstrap`              | list\[str\] | `[]`                  | Addresses to ping with a handshake before joining; each must look like `host:port` or `[ipv6]:port`.     |
+| `incoming_port`          | int         | `52780`                | UDP port the relay binds to; pass `0` or omit to let the OS pick an ephemeral port.                       |
+| `default_seed`           | string     | `"bootstrap.astreum.org:52780"` | Default address to ping before joining; set to `None` to disable the built-in default.          |
+| `additional_seeds`       | list\[str\] | `[]`                  | Extra addresses appended to the bootstrap list; each must look like `host:port` or `[ipv6]:port`.        |
+| `peer_timeout`           | int         | `900`                 | Evict peers that have not been seen within this many seconds (15 minutes).                               |
+| `peer_timeout_interval`  | int         | `10`                  | How often (seconds) the peer manager checks for stale peers.                                             |
+| `bootstrap_retry_interval` | int       | `30`                  | How often (seconds) to retry bootstrapping when the peer list is empty.                                  |
+| `storage_index_interval` | int         | `600`                 | How often (seconds) to re-advertise cold storage atoms to the closest known peer.                        |
+| `cold_storage_advertise_limit` | int   | `1000`                | Max cold storage atoms advertised per cycle using last-modified time; `-1` unlimited, `0` disable.       |
+| `incoming_queue_size_limit` | int     | `67108864`            | Soft cap (bytes) for inbound queue usage tracked by `enqueue_incoming`; set to `0` to disable.           |
+| `incoming_queue_timeout` | float      | `1.0`                 | When > 0, `enqueue_incoming` waits up to this many seconds for space before dropping the payload.        |
+| `outgoing_queue_size_limit` | int     | `67108864`            | Soft cap (bytes) for `enqueue_outgoing`-tracked outgoing queue usage; set to `0` to disable.            |
+| `outgoing_queue_timeout` | float      | `1.0`                 | When > 0, `enqueue_outgoing` waits up to this many seconds for space before dropping the payload.        |
 
 > **Note**
 > The peer‑to‑peer *route* used for object discovery is always enabled.
@@ -61,10 +74,11 @@ config = {
     "hot_storage_limit": 1073741824,         # cap hot cache at 1 GiB
     "cold_storage_limit": 10737418240,       # cap cold storage at 10 GiB
     "cold_storage_path": "./data/node1",
-    "incoming_port": 7373,
+    "cold_storage_advertise_limit": 1000,   # -1 unlimited, 0 disable, >0 limit
+    "incoming_port": 52780,
     "use_ipv6": False,
-    "bootstrap": [
-        "bootstrap.astreum.org:7373",
+    "default_seed": None,
+    "additional_seeds": [
         "127.0.0.1:7374"
     ]
 }
@@ -145,7 +159,7 @@ except ParseError as e:
 Every `Node` instance wires up structured logging automatically:
 
 - Logs land in per-instance files named `node.log` under `%LOCALAPPDATA%\Astreum\lib-py\logs/<instance_id>` on Windows and `$XDG_STATE_HOME` (or `~/.local/state`)/`Astreum/lib-py/logs/<instance_id>` on other platforms. The `<instance_id>` is the first 16 hex characters of a BLAKE3 hash of the caller's file path, so running the node from different entry points keeps their logs isolated.
-- Files rotate at midnight UTC with gzip compression (`node-YYYY-MM-DD.log.gz`) and retain 90 days by default. Override via `config["logging_retention"]`.
+- Files rotate at midnight UTC with gzip compression (`node-YYYY-MM-DD.log.gz`) and retain 90 days by default. Override via `config["logging_retention_days"]`.
 - Each event is a single JSON line containing timestamp, level, logger, message, process/thread info, module/function, and the derived `instance_id`.
 - Set `config["verbose"] = True` to mirror logs to stdout in a human-friendly format like `[2025-04-13-42-59] [info] Starting Astreum Node`.
 - The very first entry emitted is the banner `Starting Astreum Node`, signalling that the logging pipeline is live before other subsystems spin up.
@@ -156,5 +170,27 @@ Every `Node` instance wires up structured logging automatically:
 python3 -m venv venv
 source venv/bin/activate
 pip install -e .
+```
+
+for all tests
+```
 python3 -m unittest discover -s tests
 ```
+
+for individual tests
+```
+python3 -m unittest tests.node.test_atom_get
+python3 -m unittest tests.node.test_current_validator
+python3 -m unittest tests.node.test_node_connection
+python3 -m unittest tests.node.test_node_init
+python3 -m unittest tests.node.test_node_validation
+python3 -m unittest tests.node.config.default_seed
+python3 -m unittest tests.node.tokenize
+python3 -m unittest tests.node.parse
+python3 -m unittest tests.node.function
+python3 -m unittest tests.node.stack
+python3 -m unittest tests.models.test_merkle
+python3 -m unittest tests.models.test_patricia
+python3 -m unittest tests.block.atom
+python3 -m unittest tests.block.nonce
+```

astreum-0.3.48.dist-info/RECORD

@@ -0,0 +1,79 @@
+astreum/__init__.py,sha256=ibzwB_Rq3mBCgzFBVx7ssHo7-MFxpiayn5cHMIZ3Gd4,351
+astreum/node.py,sha256=6K6XeAd6h9b9LYtXE9MeJ2med0eOMZbEU5I1_RoLt30,3174
+astreum/communication/__init__.py,sha256=E0-UtzXwyX6svdbL52fI3tnUY8ILmQJ6rqw3qX2YZi0,357
+astreum/communication/difficulty.py,sha256=XUw3xfppecVy_kBsaOXBCcxICz4d3qwKvu8L4rXNtyY,886
+astreum/communication/disconnect.py,sha256=m5rwR_TJxBk4KWAUtF-qcikssVj2u-6zse1TTYZquj4,1613
+astreum/communication/incoming_queue.py,sha256=ccKmjSmkMt8Kvi7XS8Mr-iI-swJSWxjmLeABywuKokc,3357
+astreum/communication/message_pow.py,sha256=diDxc2aXjTxBQw5GWK5b-8Gybxa8AWSAcGmxF-tODnI,1103
+astreum/communication/node.py,sha256=GrcPRffWEv74W_gezYRnKVvGHBblmGEsn5Wvtw8pxC8,1700
+astreum/communication/outgoing_queue.py,sha256=CDA-A9vrkNmK-Gm4wS5htnhQhFaLaejW8dKNTsFDSNo,3818
+astreum/communication/setup.py,sha256=I1uZDxb5qyPVZ6XNi_tngtgF1CXGV4otxdNoUeRoKHs,11911
+astreum/communication/util.py,sha256=tDF6TNP-u7Q7K96JhnuWHEwfq4pASoYYcF5MakBicrg,1942
+astreum/communication/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/communication/handlers/handshake.py,sha256=XGeHslDhDn0zJS-DvvcxHwrPzmIhTMpunKOjGc8F2pg,3525
+astreum/communication/handlers/object_request.py,sha256=Wik_jEA9GiwuIaliUYThGvCLojiC2CbdGu0DfULAUa4,10791
+astreum/communication/handlers/object_response.py,sha256=nDHn81GAWMFe6iOhw4NyR0ZQxGxfr0ehZ7HcISWdtZA,7671
+astreum/communication/handlers/ping.py,sha256=bbB8JQfLR0oYgdharx0xarsn7YIaCdxlZb-AdmLw99g,1345
+astreum/communication/handlers/route_request.py,sha256=lZgapJH0RfLgp9c14H864BU3K3t03WHRGLcgpeu7SEg,2584
+astreum/communication/handlers/route_response.py,sha256=ktEft9XevZYVp6rZNCrbFIZ-HZTlYZLIUZcdRR4vkU8,1857
+astreum/communication/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/communication/models/message.py,sha256=2qln_PpKkVEoPdSGeQxUWAFxcEsHB-lz7dzTAsO94HU,4485
+astreum/communication/models/peer.py,sha256=IxZ0p8Sz6s6rsQVs8u7CB9ci17lSgXXgsHd1D4jjbXY,1845
+astreum/communication/models/ping.py,sha256=oD7IJt6JJvB2iXqkvdxMs7TwNWlK_3yk7lE7NZ-jnpA,1728
+astreum/communication/models/route.py,sha256=nb2sILlh0j1ZTyWJZBfF-jUZ1ECdAPXsin2h-_yX4Bk,3965
+astreum/communication/processors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/communication/processors/incoming.py,sha256=v2D7SZmwJEv5QOjdb6JYfnJ04Mnlswk2e2mHef7OXHM,6339
+astreum/communication/processors/outgoing.py,sha256=soI-QsO5pBqss8s6mIzTkIR7IvOS1xH9nyRM2X7un0E,1976
+astreum/communication/processors/peer.py,sha256=0NtxYXxb0PJfOfkXKvNXVWY1GYO4Ww7nSYA0AQ06ri8,4750
+astreum/crypto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/crypto/chacha20poly1305.py,sha256=01VtLx_bdJC86ifQeTA494ZdKbPM2MswDTLmAs9bl8c,2479
+astreum/crypto/ed25519.py,sha256=FRnvlN0kZlxn4j-sJKl-C9tqiz_0z4LZyXLj3KIj1TQ,1760
+astreum/crypto/quadratic_form.py,sha256=pJgbORey2NTWbQNhdyvrjy_6yjORudQ67jBz2ScHptg,4037
+astreum/crypto/wesolowski.py,sha256=SUgGXW3Id07dJtWzDcs4dluIhjqbRWQ8YWjn_mK78AQ,4092
+astreum/crypto/x25519.py,sha256=i29v4BmwKRcbz9E7NKqFDQyxzFtJUqN0St9jd7GS1uA,1137
+astreum/machine/__init__.py,sha256=TjWf9RlGuOGbCqdjJKidh8W4pCzUoLpi3FgutssEGoQ,479
+astreum/machine/parser.py,sha256=Z_Y0Sax0rPh8JcIo19-iNDQoc5GTdGQkmfFyLpCB4bw,1757
+astreum/machine/tokenizer.py,sha256=6wPqR_D3h5BEvR78XKtD45ouy77RZBbz4Yh4jHSmN4o,2394
+astreum/machine/evaluations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/machine/evaluations/high_evaluation.py,sha256=cqYudR9WAdVz9dURDyuQhZsuhWbmjbdw9x3UxDEYpPI,9971
+astreum/machine/evaluations/low_evaluation.py,sha256=t3xfZCKrvRMBTmc4PUp8tywr2uIOScgQnWaR6eMG3wE,10370
+astreum/machine/evaluations/script_evaluation.py,sha256=eWouYUwTYzaqUyXqEe-lAJFIluW0gMeCDdXqle88oWw,864
+astreum/machine/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/machine/models/environment.py,sha256=WjP6GRX_8e0-BAhzRLvQ6fYtKQEVR0LZi7DZNZS0TSE,1019
+astreum/machine/models/expression.py,sha256=KjN6TxikqpRK_vwx5f4N4RNZCqoKYBdR6rGBBJp2-Bk,7637
+astreum/machine/models/meter.py,sha256=5q2PFW7_jmgKVM1-vwE4RRjMfPEthUA4iu1CwR-Axws,505
+astreum/storage/__init__.py,sha256=Flk6WXT2xGFHWWJiZHK3O5OpjoLTOFMqqIiJTtD58kY,111
+astreum/storage/providers.py,sha256=-nOEfoecraTBhPA3ERgz8UwEOJ9DKD-wnHtaSoR6WjU,740
+astreum/storage/requests.py,sha256=5D9F2uWdwqhvfPM3TWrtCMopseFyPV6WKNKbxT5uLlY,1067
+astreum/storage/setup.py,sha256=t6EtAan9N7wrTEcU927z-sM5L5mboMnKk218fwfTRy8,893
+astreum/storage/actions/get.py,sha256=2yA00Odjefzf2v5Qpwl6H0LSG8sb7KLmfbxkA9Fnivo,11088
+astreum/storage/actions/set.py,sha256=TGD1JS9zRLO7AVDTWwP2st7DWabfB51trVAghUrja4A,6386
+astreum/storage/models/atom.py,sha256=fAIXW7bMzsyioZL4UOyu_Rpjvw2amWNQNbyTE3m56sk,2707
+astreum/storage/models/trie.py,sha256=kZelNuMTGKnG21Rt4Fo72bp4d1P_5W8zAH7hWk4zN1k,17577
+astreum/utils/bytes.py,sha256=9QTWC2JCdwWLB5R2mPtmjPro0IUzE58DL3uEul4AheE,846
+astreum/utils/config.py,sha256=b2ei_LtPxnQs__dJvBnNfjQiQjnLOJM0-EGrO_1PEYw,11256
+astreum/utils/integer.py,sha256=iQt-klWOYVghu_NOT341MmHbOle4FDT3by4PNKNXscg,736
+astreum/utils/logging.py,sha256=YbFtt_h6_3mpnOomffGW0DnI1Y1cwl_vb6Zsu1_W_Xg,6692
+astreum/validation/__init__.py,sha256=cRlrwE3MqtBrda9ZxLmtCEOY3P5oJnXpjE4YDNHCnpI,322
+astreum/validation/constants.py,sha256=p-hO8u3PJob5UFNHzSm-HqIe6z-QC7L4TldRXA7IsvQ,60
+astreum/validation/genesis.py,sha256=7JSZEa5-AdaWn2sCO0G2bh8-4OG-mio585U1lJ9ZjWk,1992
+astreum/validation/node.py,sha256=AuY186eqlmXMIbFnQrDO8tn6gmuaj-sI6l1htIwoxnA,6935
+astreum/validation/validator.py,sha256=MmxkOMWQeUg4peIt5FHz1A1Fv-RvbGNCa49sDj8b7QM,3873
+astreum/validation/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/validation/models/account.py,sha256=WRRaNHqQuoc0hBrDmPF2gZvQCl5557QX1FOYDOmpkqE,2666
+astreum/validation/models/accounts.py,sha256=iUMs6LvmMea-gxd6-ujkFjqhWmuW1cl9XTWGXQkpLys,2388
+astreum/validation/models/block.py,sha256=SfjKO3mez67vHHxOdpsJn1WihKlBou0RsBzl7KiOnqI,21081
+astreum/validation/models/fork.py,sha256=R9yBKThlvAzqGf4nAe5yVyFDX7tIX5TfnH_KDEZ7Azg,20630
+astreum/validation/models/receipt.py,sha256=IRDrAEApdMIuBnRUuvueZ0X45Fq2iEvl40sbW3u1mso,3883
+astreum/validation/models/transaction.py,sha256=TKylwk3AqWW6pcXFAowR7A4BT43nQxPRQ-NseE3ELtQ,8825
+astreum/validation/workers/__init__.py,sha256=GH8G4j7ONbtcoqBiX1d1I16Ikiu3fjGM6pUSQXqDtiw,228
+astreum/validation/workers/validation.py,sha256=60L5KiX6e5-5KN4NLAF9jclfyRqDX_ju4qOTx92PnY4,15349
+astreum/verification/__init__.py,sha256=Ec7_CTXbHYtiw1KK3oJx0s96loSnVX0i863_FLHv_es,130
+astreum/verification/discover.py,sha256=ubMdNTE8gzDQ9B8NzycrHpKVHfnqaBQgNkEHywoVjws,2449
+astreum/verification/node.py,sha256=xYhVRhRW_wKIdFiWzrC5A-xeHy1P6cRJwG5MWRA8KTM,2005
+astreum/verification/worker.py,sha256=BM8feAJ0IVKyHYzdC3YRZwEItOxUhQdmtu2RtksIMvI,6460
+astreum-0.3.48.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.3.48.dist-info/METADATA,sha256=pR6MmP4QXroddMYtP9BHnOaVA1C_glrH5fY42waippM,10987
+astreum-0.3.48.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+astreum-0.3.48.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.3.48.dist-info/RECORD,,