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

astreum/utils/config.py

@@ -1,76 +1,293 @@
-
-from pathlib import Path
-from typing import Dict
-
+
+from pathlib import Path
+from typing import Dict
+
 DEFAULT_HOT_STORAGE_LIMIT = 1 << 30  # 1 GiB
 DEFAULT_COLD_STORAGE_LIMIT = 10 << 30  # 10 GiB
+DEFAULT_COLD_STORAGE_ADVERTISE_LIMIT = 1000
+DEFAULT_INCOMING_PORT = 52780
+DEFAULT_LOGGING_RETENTION_DAYS = 90
 DEFAULT_PEER_TIMEOUT_SECONDS = 15 * 60  # 15 minutes
 DEFAULT_PEER_TIMEOUT_INTERVAL_SECONDS = 10  # 10 seconds
+DEFAULT_BOOTSTRAP_RETRY_INTERVAL_SECONDS = 30  # 30 seconds
+DEFAULT_STORAGE_INDEX_INTERVAL_SECONDS = 600  # 10 minutes
+DEFAULT_ATOM_FETCH_INTERVAL_SECONDS = 0.25
+DEFAULT_ATOM_FETCH_RETRIES = 8
+DEFAULT_INCOMING_QUEUE_SIZE_LIMIT_BYTES = 64 * 1024 * 1024  # 64 MiB
+DEFAULT_INCOMING_QUEUE_TIMEOUT_SECONDS = 1.0
+DEFAULT_OUTGOING_QUEUE_SIZE_LIMIT_BYTES = 64 * 1024 * 1024  # 64 MiB
+DEFAULT_OUTGOING_QUEUE_TIMEOUT_SECONDS = 1.0
+DEFAULT_SEED = "bootstrap.astreum.org:52780"
+DEFAULT_VERIFICATION_MAX_STALE_SECONDS = 10
+DEFAULT_VERIFICATION_MAX_FUTURE_SKEW_SECONDS = 2
+
+
+def config_setup(config: Dict = {}):
+    """
+    Normalize configuration values before the node starts.
+    """
+    chain_str = config.get("chain")
+    if chain_str not in {"main", "test"}:
+        chain_str = None
+    chain_id_raw = config.get("chain_id")
+    if chain_id_raw is None:
+        chain_id = 1 if chain_str == "main" else 0
+    else:
+        try:
+            chain_id = int(chain_id_raw)
+        except (TypeError, ValueError) as exc:
+            raise ValueError(
+                f"chain_id must be an integer: {chain_id_raw!r}"
+            ) from exc
+    if chain_str is None:
+        chain_str = "main" if chain_id == 1 else "test"
+    config["chain"] = chain_str
+    config["chain_id"] = chain_id
+
+    hot_limit_raw = config.get(
+        "hot_storage_limit", config.get("hot_storage_default_limit", DEFAULT_HOT_STORAGE_LIMIT)
+    )
+    try:
+        config["hot_storage_limit"] = int(hot_limit_raw)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"hot_storage_limit must be an integer: {hot_limit_raw!r}"
+        ) from exc
+
+    cold_limit_raw = config.get("cold_storage_limit", DEFAULT_COLD_STORAGE_LIMIT)
+    try:
+        config["cold_storage_limit"] = int(cold_limit_raw)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"cold_storage_limit must be an integer: {cold_limit_raw!r}"
+        ) from exc
+
+    cold_path_raw = config.get("cold_storage_path")
+    if cold_path_raw:
+        try:
+            path_obj = Path(cold_path_raw)
+            path_obj.mkdir(parents=True, exist_ok=True)
+            config["cold_storage_path"] = str(path_obj)
+        except OSError:
+            config["cold_storage_path"] = None
+    else:
+        config["cold_storage_path"] = None
 
-
-def config_setup(config: Dict = {}):
-    """
-    Normalize configuration values before the node starts.
-    """
-    chain_str = config.get("chain", "test")
-    if chain_str not in {"main", "test"}:
-        chain_str = "test"
-    config["chain"] = chain_str
-    config["chain_id"] = 1 if chain_str == "main" else 0
-
-    hot_limit_raw = config.get(
-        "hot_storage_limit", config.get("hot_storage_default_limit", DEFAULT_HOT_STORAGE_LIMIT)
+    advertise_limit_raw = config.get(
+        "cold_storage_advertise_limit", DEFAULT_COLD_STORAGE_ADVERTISE_LIMIT
     )
     try:
-        config["hot_storage_default_limit"] = int(hot_limit_raw)
+        advertise_limit = int(advertise_limit_raw)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            "cold_storage_advertise_limit must be an integer: "
+            f"{advertise_limit_raw!r}"
+        ) from exc
+    if advertise_limit < -1:
+        raise ValueError(
+            "cold_storage_advertise_limit must be -1, 0, or a positive integer"
+        )
+    config["cold_storage_advertise_limit"] = advertise_limit
+
+    retention_raw = config.get(
+        "logging_retention_days",
+        config.get("logging_retention", config.get("retention_days", DEFAULT_LOGGING_RETENTION_DAYS)),
+    )
+    try:
+        config["logging_retention_days"] = int(retention_raw)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"logging_retention_days must be an integer: {retention_raw!r}"
+        ) from exc
+
+    if "incoming_port" in config:
+        incoming_port_raw = config["incoming_port"]
+    else:
+        incoming_port_raw = DEFAULT_INCOMING_PORT
+    try:
+        config["incoming_port"] = int(incoming_port_raw)
     except (TypeError, ValueError) as exc:
         raise ValueError(
-            f"hot_storage_limit must be an integer: {hot_limit_raw!r}"
+            f"incoming_port must be an integer: {incoming_port_raw!r}"
         ) from exc
+    if config["incoming_port"] < 0:
+        raise ValueError("incoming_port must be 0 or a positive integer")
 
-    cold_limit_raw = config.get("cold_storage_limit", DEFAULT_COLD_STORAGE_LIMIT)
+    incoming_queue_limit_raw = config.get(
+        "incoming_queue_size_limit", DEFAULT_INCOMING_QUEUE_SIZE_LIMIT_BYTES
+    )
     try:
-        config["cold_storage_limit"] = int(cold_limit_raw)
+        incoming_queue_limit = int(incoming_queue_limit_raw)
     except (TypeError, ValueError) as exc:
         raise ValueError(
-            f"cold_storage_limit must be an integer: {cold_limit_raw!r}"
+            f"incoming_queue_size_limit must be an integer: {incoming_queue_limit_raw!r}"
         ) from exc
+    if incoming_queue_limit < 0:
+        raise ValueError("incoming_queue_size_limit must be a non-negative integer")
+    config["incoming_queue_size_limit"] = incoming_queue_limit
 
-    cold_path_raw = config.get("cold_storage_path")
-    if cold_path_raw:
-        try:
-            path_obj = Path(cold_path_raw)
-            path_obj.mkdir(parents=True, exist_ok=True)
-            config["cold_storage_path"] = str(path_obj)
-        except OSError:
-            config["cold_storage_path"] = None
-    else:
-        config["cold_storage_path"] = None
+    incoming_queue_timeout_raw = config.get(
+        "incoming_queue_timeout", DEFAULT_INCOMING_QUEUE_TIMEOUT_SECONDS
+    )
+    try:
+        incoming_queue_timeout = float(incoming_queue_timeout_raw)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"incoming_queue_timeout must be a number: {incoming_queue_timeout_raw!r}"
+        ) from exc
+    if incoming_queue_timeout < 0:
+        raise ValueError("incoming_queue_timeout must be a non-negative number")
+    config["incoming_queue_timeout"] = incoming_queue_timeout
 
     peer_timeout_raw = config.get("peer_timeout", DEFAULT_PEER_TIMEOUT_SECONDS)
     try:
         peer_timeout = int(peer_timeout_raw)
     except (TypeError, ValueError) as exc:
         raise ValueError(
-            f"peer_timeout must be an integer: {peer_timeout_raw!r}"
+            f"peer_timeout must be an integer: {peer_timeout_raw!r}"
+        ) from exc
+
+    if peer_timeout <= 0:
+        raise ValueError("peer_timeout must be a positive integer")
+
+    config["peer_timeout"] = peer_timeout
+
+    interval_raw = config.get("peer_timeout_interval", DEFAULT_PEER_TIMEOUT_INTERVAL_SECONDS)
+    try:
+        interval = int(interval_raw)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"peer_timeout_interval must be an integer: {interval_raw!r}"
+        ) from exc
+
+    if interval <= 0:
+        raise ValueError("peer_timeout_interval must be a positive integer")
+
+    config["peer_timeout_interval"] = interval
+
+    bootstrap_retry_raw = config.get(
+        "bootstrap_retry_interval", DEFAULT_BOOTSTRAP_RETRY_INTERVAL_SECONDS
+    )
+    try:
+        bootstrap_retry_interval = int(bootstrap_retry_raw)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"bootstrap_retry_interval must be an integer: {bootstrap_retry_raw!r}"
+        ) from exc
+    if bootstrap_retry_interval <= 0:
+        raise ValueError("bootstrap_retry_interval must be a positive integer")
+    config["bootstrap_retry_interval"] = bootstrap_retry_interval
+
+    storage_index_raw = config.get(
+        "storage_index_interval", DEFAULT_STORAGE_INDEX_INTERVAL_SECONDS
+    )
+    try:
+        storage_index_interval = int(storage_index_raw)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"storage_index_interval must be an integer: {storage_index_raw!r}"
         ) from exc
+    if storage_index_interval <= 0:
+        raise ValueError("storage_index_interval must be a positive integer")
+    config["storage_index_interval"] = storage_index_interval
 
-    if peer_timeout <= 0:
-        raise ValueError("peer_timeout must be a positive integer")
+    atom_fetch_interval_raw = config.get(
+        "atom_fetch_interval", DEFAULT_ATOM_FETCH_INTERVAL_SECONDS
+    )
+    try:
+        atom_fetch_interval = float(atom_fetch_interval_raw)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"atom_fetch_interval must be a number: {atom_fetch_interval_raw!r}"
+        ) from exc
+    if atom_fetch_interval < 0:
+        raise ValueError("atom_fetch_interval must be a non-negative number")
+    config["atom_fetch_interval"] = atom_fetch_interval
 
-    config["peer_timeout"] = peer_timeout
+    atom_fetch_retries_raw = config.get(
+        "atom_fetch_retries", DEFAULT_ATOM_FETCH_RETRIES
+    )
+    try:
+        atom_fetch_retries = int(atom_fetch_retries_raw)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"atom_fetch_retries must be an integer: {atom_fetch_retries_raw!r}"
+        ) from exc
+    if atom_fetch_retries < 0:
+        raise ValueError("atom_fetch_retries must be a non-negative integer")
+    config["atom_fetch_retries"] = atom_fetch_retries
 
-    interval_raw = config.get("peer_timeout_interval", DEFAULT_PEER_TIMEOUT_INTERVAL_SECONDS)
+    outgoing_queue_limit_raw = config.get(
+        "outgoing_queue_size_limit", DEFAULT_OUTGOING_QUEUE_SIZE_LIMIT_BYTES
+    )
     try:
-        interval = int(interval_raw)
+        outgoing_queue_limit = int(outgoing_queue_limit_raw)
     except (TypeError, ValueError) as exc:
         raise ValueError(
-            f"peer_timeout_interval must be an integer: {interval_raw!r}"
+            f"outgoing_queue_size_limit must be an integer: {outgoing_queue_limit_raw!r}"
         ) from exc
+    if outgoing_queue_limit < 0:
+        raise ValueError("outgoing_queue_size_limit must be a non-negative integer")
+    config["outgoing_queue_size_limit"] = outgoing_queue_limit
 
-    if interval <= 0:
-        raise ValueError("peer_timeout_interval must be a positive integer")
+    outgoing_queue_timeout_raw = config.get(
+        "outgoing_queue_timeout", DEFAULT_OUTGOING_QUEUE_TIMEOUT_SECONDS
+    )
+    try:
+        outgoing_queue_timeout = float(outgoing_queue_timeout_raw)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"outgoing_queue_timeout must be a number: {outgoing_queue_timeout_raw!r}"
+        ) from exc
+    if outgoing_queue_timeout < 0:
+        raise ValueError("outgoing_queue_timeout must be a non-negative number")
+    config["outgoing_queue_timeout"] = outgoing_queue_timeout
 
-    config["peer_timeout_interval"] = interval
+    max_stale_raw = config.get(
+        "verification_max_stale_seconds", DEFAULT_VERIFICATION_MAX_STALE_SECONDS
+    )
+    try:
+        max_stale = int(max_stale_raw)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"verification_max_stale_seconds must be an integer: {max_stale_raw!r}"
+        ) from exc
+    if max_stale < 0:
+        raise ValueError("verification_max_stale_seconds must be a non-negative integer")
+    config["verification_max_stale_seconds"] = max_stale
 
-    return config
+    max_future_raw = config.get(
+        "verification_max_future_skew", DEFAULT_VERIFICATION_MAX_FUTURE_SKEW_SECONDS
+    )
+    try:
+        max_future = int(max_future_raw)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"verification_max_future_skew must be an integer: {max_future_raw!r}"
+        ) from exc
+    if max_future < 0:
+        raise ValueError("verification_max_future_skew must be a non-negative integer")
+    config["verification_max_future_skew"] = max_future
+
+    if "default_seeds" in config:
+        raise ValueError("default_seeds is no longer supported; use default_seed")
+
+    if "default_seed" in config:
+        default_seed_raw = config["default_seed"]
+    else:
+        default_seed_raw = DEFAULT_SEED
+
+    if default_seed_raw is None:
+        config["default_seed"] = None
+    elif isinstance(default_seed_raw, str):
+        config["default_seed"] = default_seed_raw
+    else:
+        raise ValueError("default_seed must be a string or None")
+
+    additional_seeds_raw = config.get("additional_seeds", [])
+    if isinstance(additional_seeds_raw, (list, tuple)):
+        config["additional_seeds"] = list(additional_seeds_raw)
+    else:
+        raise ValueError("additional_seeds must be a list of strings")
+
+    return config

astreum/utils/logging.py

@@ -159,7 +159,7 @@ def logging_setup(config: dict) -> logging.LoggerAdapter:
     product = _PRODUCT_NAME
     instance_id = _derive_instance_id()
 
-    retention_value = config.get("retention_days")
+    retention_value = config.get("logging_retention_days")
     retention_days = int(retention_value) if retention_value is not None else 90
 
     verbose = bool(config.get("verbose", False))

astreum/{consensus → validation}/__init__.py

@@ -1,20 +1,16 @@
 from .models.account import Account
 from .models.accounts import Accounts
 from .models.block import Block
-from .models.chain import Chain
 from .models.fork import Fork
 from .models.receipt import Receipt
 from .models.transaction import Transaction
-from .setup import consensus_setup
 
 
 __all__ = [
     "Block",
-    "Chain",
     "Fork",
     "Receipt",
     "Transaction",
     "Account",
     "Accounts",
-    "consensus_setup",
 ]

astreum/validation/constants.py

@@ -0,0 +1,2 @@
+TREASURY_ADDRESS = b"\x01" * 32
+BURN_ADDRESS = b"\x00" * 32

astreum/{consensus → validation}/genesis.py

@@ -2,16 +2,14 @@ from __future__ import annotations
 
 from typing import Any, List
 
+from .constants import BURN_ADDRESS, TREASURY_ADDRESS
 from .models.account import Account
 from .models.accounts import Accounts
 from .models.block import Block
 from ..storage.models.atom import ZERO32
 from ..storage.models.trie import Trie
 from ..utils.integer import int_to_bytes
-
-TREASURY_ADDRESS = b"\x01" * 32
-BURN_ADDRESS = b"\x00" * 32
-
+from time import time
 
 def create_genesis_block(
     node: Any,
@@ -49,13 +47,13 @@ def create_genesis_block(
         previous_block_hash=ZERO32,
         previous_block=None,
         number=0,
-        timestamp=0,
+        timestamp=int(time()),
         accounts_hash=accounts_root,
         transactions_total_fees=0,
         transactions_hash=ZERO32,
         receipts_hash=ZERO32,
         delay_difficulty=0,
-        validator_public_key=validator_pk,
+        validator_public_key_bytes=validator_pk,
         nonce=0,
         signature=b"",
         accounts=accounts,

astreum/{consensus → validation}/models/account.py

@@ -35,7 +35,7 @@ class Account:
     @classmethod
     def from_atom(cls, node: Any, root_id: bytes) -> "Account":
 
-        account_atoms = node.get_atom_list_from_storage(root_hash=root_id)
+        account_atoms = node.get_atom_list(root_id)
 
         if account_atoms is None or len(account_atoms) != 5:
             raise ValueError("malformed account atom list")