astreum 0.2.61__py3-none-any.whl → 0.3.1__py3-none-any.whl

{astreum-0.2.61.dist-info → astreum-0.3.1.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.61
-Summary: Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
+Version: 0.3.1
+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
-Project-URL: Issues, https://github.com/astreum/lib/issues
+Project-URL: Homepage, https://github.com/astreum/lib-py
+Project-URL: Issues, https://github.com/astreum/lib-py/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
@@ -18,7 +18,7 @@ Dynamic: license-file
 
 # lib
 
-Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
+Python library to interact with the Astreum blockchain and its virtual machine.
 
 [View on PyPI](https://pypi.org/project/astreum/)
 
@@ -30,21 +30,21 @@ When initializing an `astreum.Node`, pass a dictionary with any of the options b
 
 | Parameter                   | Type       | Default        | Description                                                                                                                                                                      |
 | --------------------------- | ---------- | -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `machine-only`              | bool       | `True`         | When **True** the node starts in *machine‑only* mode: no storage subsystem and no relay networking – only the Lispeum VM. Set to **False** to enable storage and relay features. |
-| `relay_secret_key`          | hex string | Auto‑generated | Ed25519 private key that identifies the node on the network. If omitted, a fresh keypair is generated and kept in‑memory.                                                        |
-| `validation_secret_key`     | hex string | `None`         | X25519 private key that lets the node participate in the validation route. Leave unset for a non‑validator node.                                                                 |
-| `storage_path`              | string     | `None`         | Directory where objects are persisted. If *None*, the node uses an in‑memory store.                                                                                              |
-| `storage_get_relay_timeout` | float      | `5`            | Seconds to wait for an object requested from peers before timing‑out.                                                                                                            |
+| `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).                                                                                                                           |
 | `verbose`                   | bool       | `False`        | When **True**, also mirror JSON logs to stdout with a human-readable format.                                                                                                     |
 
 ### Networking
 
-| Parameter       | Type                    | Default | Description                                                                         |
-| --------------- | ----------------------- | ------- | ----------------------------------------------------------------------------------- |
-| `use_ipv6`      | bool                    | `False` | Listen on IPv6 as well as IPv4.                                                     |
-| `incoming_port` | int                     | `7373`  | UDP port the relay binds to.                                                        |
-| `bootstrap`     | list\[tuple\[str, int]] | `[]`    | Initial peers used to join the network, e.g. `[ ("bootstrap.astreum.org", 7373) ]`. |
+| 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`.     |
 
 > **Note**
 > The peer‑to‑peer *route* used for object discovery is always enabled.
@@ -56,16 +56,16 @@ When initializing an `astreum.Node`, pass a dictionary with any of the options b
 from astreum.node import Node
 
 config = {
-    "machine-only": False,                   # run full node
     "relay_secret_key": "ab…cd",             # optional – hex encoded
     "validation_secret_key": "12…34",        # optional – validator
-    "storage_path": "./data/node1",
-    "storage_get_relay_timeout": 5,
+    "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,
     "use_ipv6": False,
     "bootstrap": [
-        ("bootstrap.astreum.org", 7373),
-        ("127.0.0.1", 7374)
+        "bootstrap.astreum.org:7373",
+        "127.0.0.1:7374"
     ]
 }
 
@@ -73,9 +73,10 @@ node = Node(config)
 # … your code …
 ```
 
-## Lispeum Machine Quickstart
 
-The Lispeum virtual machine (VM) is embedded inside `astreum.Node`. You feed it Lispeum source text, and the node tokenizes, parses, and **evaluates** the resulting AST inside an isolated environment.
+## Astreum Machine Quickstart
+
+The Astreum virtual machine (VM) is embedded inside `astreum.Node`. You feed it Astreum script, and the node tokenizes, parses, and evaluates.
 
 ```python
 # Define a named function int.add (stack body) and call it with bytes 1 and 2
@@ -108,10 +109,10 @@ params = Expr.ListExpr([Expr.Symbol("a"), Expr.Symbol("b")])
 int_add_fn = Expr.ListExpr([fn_body, params, Expr.Symbol("fn")])
 
 # 4) Store under the name "int.add"
-node.env_set(env_id, b"int.add", int_add_fn)
+node.env_set(env_id, "int.add", int_add_fn)
 
 # 5) Retrieve the function and call it with bytes 1 and 2
-bound = node.env_get(env_id, b"int.add")
+bound = node.env_get(env_id, "int.add")
 call = Expr.ListExpr([Expr.Byte(1), Expr.Byte(2), bound])
 res  = node.high_eval(env_id, call)
 

astreum-0.3.1.dist-info/RECORD

@@ -0,0 +1,62 @@
+astreum/__init__.py,sha256=GkEW_ReYore8_0nEOvPnZLUa3lO7CgMWu6LeEjrGXEk,325
+astreum/node.py,sha256=cHZyq9ImhCB9PSROKR5lFsUau6VLCjRIfiJSZhCPFzI,2103
+astreum/communication/__init__.py,sha256=wNxzsAk8Fol9cGMPuVvY4etrrMqn3SjZq1dE82kFrxw,228
+astreum/communication/setup.py,sha256=qliXCj2uHvzullCPSVtUuEG9zdqHewKgYfQLfsM8tao,7236
+astreum/communication/start.py,sha256=lfud8VvLeKFbkF_TwHFODg20RVpClUa4a_zsHB7ynxk,1853
+astreum/communication/util.py,sha256=bJ3td3naDzmCelAJQpLwiDMoRBkijQl9YLROjsWyOrI,1256
+astreum/communication/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/communication/handlers/handshake.py,sha256=twd18nnfYcyC8hLXZ0EDwUw-2mPQGRf1RYdW21x9CHM,2378
+astreum/communication/handlers/ping.py,sha256=xY-QT0IoeNPKR1hyruRwJa2N8_op7aPOCZUk9X-kZWk,1258
+astreum/communication/handlers/storage_request.py,sha256=rUWhoeOxVZHcvEMxi74hN9XF9SFHe9Uw-9q4pBP-KwE,2406
+astreum/communication/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/communication/models/message.py,sha256=Wl1IITj7eY9_q0IOT4J7c5gsjS1bF51CH7GcSSuu5OM,3327
+astreum/communication/models/peer.py,sha256=CbqkyCwhFCiC2spd1-KjNdeVGNjjt2ECVs8uHot-ETI,875
+astreum/communication/models/ping.py,sha256=u_DQTZJsbMdYiDDqjdZDsLaN5na2m9WZjVeEM3zq9_Y,955
+astreum/communication/models/route.py,sha256=LRHx0R1MSIln92GQbyDrZpE_hfiHDiSG_3z1Ssq_1n4,4032
+astreum/consensus/__init__.py,sha256=VZR_NyGSD5VvZp3toD2zpdYwFDLBIcckeVZXFPlruuU,425
+astreum/consensus/genesis.py,sha256=RI9AzQFmDTgNFuiiTmW2dDiGcURIUGmThdRpxWrUOBk,1962
+astreum/consensus/setup.py,sha256=lrEapfpJXKqw4iwST11-tqPAI2VW2h3H6Ue4JDAtrP4,3142
+astreum/consensus/start.py,sha256=ZUa77cINmj5AzGR8dnZ1KS0OeDIyesSmrEOx0zo4HBI,2581
+astreum/consensus/validator.py,sha256=cqcmw1WEB8DkznNX_Mn8tmE956rVSNCPv1FicdL8EAQ,3647
+astreum/consensus/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/consensus/models/account.py,sha256=3QcT59QUZynysLSbiywidFYVzYJ3LR6qia7JwXOwn4I,2690
+astreum/consensus/models/accounts.py,sha256=iUMs6LvmMea-gxd6-ujkFjqhWmuW1cl9XTWGXQkpLys,2388
+astreum/consensus/models/block.py,sha256=nNtw9TbEAF1mIEfgJr1fuswcZ0B63SVnuBANqJ5Zaac,13531
+astreum/consensus/models/chain.py,sha256=SIIDFSYbag76kTUNwnuJ2_zyuhFsvT7n5HgrVTxBrvE,2797
+astreum/consensus/models/fork.py,sha256=IbXRB93bUg2k3q3oQ9dOPzozV-rY-TEDFjYrw-WBymE,3859
+astreum/consensus/models/receipt.py,sha256=KjKKjYp_LnP2zkX1FLIwD_4hqKV1b2TPfp43tY701q4,3336
+astreum/consensus/models/transaction.py,sha256=AYa1Q-BaYW3mkOv1e3WbvDFEsYamKMiFrja-eO2zU_Y,7475
+astreum/consensus/workers/__init__.py,sha256=bS5FjbevbIR5FHbVGnT4Jli17VIld_5auemRw4CaHFU,278
+astreum/consensus/workers/discovery.py,sha256=ckko9286WaK0qAaUpk_pHmQe_N3F87iGZu67OhCdtY8,2487
+astreum/consensus/workers/validation.py,sha256=1jwFUL1zztuzLiYAmi92-KTUq97yraFAhuvhNhFJeLs,12223
+astreum/consensus/workers/verify.py,sha256=eadF27iXOnMife_Pwz65lVwUyTEU8LGIcdGkCT_nzo0,3487
+astreum/crypto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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=0tKOvW8T7EEHrL5pZtMUSnUszYTPWSP2xnEocr1eIOk,9778
+astreum/machine/evaluations/low_evaluation.py,sha256=n3LwHDD889PAoj1XW7D2Eu4WCalx5nl0mKoLrgdoLpo,10337
+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=yYr9ktk-NWPL4EXwHz7ePvr9eNvfSBQe3yzRUz06yas,7675
+astreum/machine/models/meter.py,sha256=5q2PFW7_jmgKVM1-vwE4RRjMfPEthUA4iu1CwR-Axws,505
+astreum/storage/__init__.py,sha256=Flk6WXT2xGFHWWJiZHK3O5OpjoLTOFMqqIiJTtD58kY,111
+astreum/storage/setup.py,sha256=udwLpSCFpneKH9DlxUB40EVjmhjqQQ2hS4dePwQKkL8,1508
+astreum/storage/actions/get.py,sha256=XRNOUzD3OjMpfFPyhQQt2rE5dpS_Hdp9Yf5SYELjm30,2572
+astreum/storage/actions/set.py,sha256=-eyHJW5xPRbkDV8YvPQsp_SEFkCt4HEQ0VK2soYRXvg,4210
+astreum/storage/models/atom.py,sha256=FY_bgtoju59Yo7TL1DTFTr9_pRMNBuH6-u59D6bz2fc,3163
+astreum/storage/models/trie.py,sha256=Bn3ssPGI7YGS4iUH5ESvpG1NE6Ljx2Xo7wkEpQhjKUY,17587
+astreum/utils/bytes.py,sha256=9QTWC2JCdwWLB5R2mPtmjPro0IUzE58DL3uEul4AheE,846
+astreum/utils/integer.py,sha256=iQt-klWOYVghu_NOT341MmHbOle4FDT3by4PNKNXscg,736
+astreum/utils/logging.py,sha256=mRDtWSCj8vKt58WGKLNSkK9Oa0graNVSoS8URby4Q9g,6684
+astreum-0.3.1.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.3.1.dist-info/METADATA,sha256=_fPZGHAf0_YTfkErbQwTEovrBE0x_MbUPp8uXJ04JUE,7716
+astreum-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+astreum-0.3.1.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.3.1.dist-info/RECORD,,

astreum/_communication/setup.py

@@ -1,322 +0,0 @@
-import socket, threading
-from datetime import datetime, timezone
-from queue import Queue
-from typing import Tuple, Optional
-from cryptography.hazmat.primitives.asymmetric import ed25519
-from cryptography.hazmat.primitives import serialization
-from cryptography.hazmat.primitives.asymmetric.x25519 import (
-    X25519PrivateKey,
-    X25519PublicKey,
-)
-
-from typing import TYPE_CHECKING
-if TYPE_CHECKING:
-    from .. import Node
-
-from . import Route, Message
-from .message import MessageTopic
-from .peer import Peer
-from .ping import Ping
-from .util import address_str_to_host_and_port
-
-def load_x25519(hex_key: Optional[str]) -> X25519PrivateKey:
-    """DH key for relaying (always X25519)."""
-    return 
-
-def load_ed25519(hex_key: Optional[str]) -> Optional[ed25519.Ed25519PrivateKey]:
-    """Signing key for validation (Ed25519), or None if absent."""
-    return ed25519.Ed25519PrivateKey.from_private_bytes(bytes.fromhex(hex_key)) \
-           if hex_key else None
-
-def make_routes(
-    relay_pk: X25519PublicKey,
-    val_sk: Optional[ed25519.Ed25519PrivateKey]
-) -> Tuple[Route, Optional[Route]]:
-    """Peer route (DH pubkey) + optional validation route (ed pubkey)."""
-    peer_rt = Route(relay_pk)
-    val_rt  = Route(val_sk.public_key()) if val_sk else None
-    return peer_rt, val_rt
-
-def setup_outgoing(
-    use_ipv6: bool
-) -> Tuple[socket.socket, Queue, threading.Thread]:
-    fam  = socket.AF_INET6 if use_ipv6 else socket.AF_INET
-    sock = socket.socket(fam, socket.SOCK_DGRAM)
-    q    = Queue()
-    thr  = threading.Thread(target=lambda: None, daemon=True)
-    thr.start()
-    return sock, q, thr
-
-def make_maps():
-    """Empty lookup maps: peers and addresses."""
-    return
-
-
-def process_incoming_messages(node: "Node") -> None:
-    """Process incoming messages (placeholder)."""
-    while True:
-        try:
-            data, addr = node.incoming_queue.get()
-        except Exception as exc:
-            print(f"Error taking from incoming queue: {exc}")
-            continue
-
-        try:
-            message = Message.from_bytes(data)
-        except Exception as exc:
-            print(f"Error decoding message: {exc}")
-            continue
-
-        if message.handshake:
-            sender_key = message.sender
-
-            try:
-                sender_public_key_bytes = sender_key.public_bytes(
-                    encoding=serialization.Encoding.Raw,
-                    format=serialization.PublicFormat.Raw,
-                )
-            except Exception as exc:
-                print(f"Error extracting sender key bytes: {exc}")
-                continue
-
-            # Normalize remote address (IPv6 tuples may be 4 elements)
-            try:
-                host, port = addr[0], int(addr[1])
-            except Exception:
-                continue
-            address_key = (host, port)
-
-            old_key_bytes = node.addresses.get(address_key)
-            node.addresses[address_key] = sender_public_key_bytes
-
-            if old_key_bytes is None:
-                # brand-new address -> brand-new peer
-                try:
-                    peer = Peer(node.relay_secret_key, sender_key)
-                except Exception:
-                    continue
-                peer.address = address_key
-
-                node.peers[sender_public_key_bytes] = peer
-                node.peer_route.add_peer(sender_public_key_bytes, peer)
-
-                response = Message(handshake=True, sender=node.relay_public_key)
-                node.outgoing_queue.put((response.to_bytes(), address_key))
-                continue
-            
-            elif old_key_bytes == sender_public_key_bytes:
-                # existing mapping with same key -> nothing to change
-                peer = node.peers.get(sender_public_key_bytes)
-                if peer is not None:
-                    peer.address = address_key
-            
-            else:
-                # address reused with a different key -> replace peer
-                node.peers.pop(old_key_bytes, None)
-                try:
-                    node.peer_route.remove_peer(old_key_bytes)
-                except Exception:
-                    pass
-                try:
-                    peer = Peer(node.relay_secret_key, sender_key)
-                except Exception:
-                    continue
-                peer.address = address_key
-
-                node.peers[sender_public_key_bytes] = peer
-                node.peer_route.add_peer(sender_public_key_bytes, peer)
-
-        match message.topic:
-            case MessageTopic.PING:
-                try:
-                    host, port = addr[0], int(addr[1])
-                except Exception:
-                    continue
-                address_key = (host, port)
-                sender_public_key_bytes = node.addresses.get(address_key)
-                if sender_public_key_bytes is None:
-                    continue
-                peer = node.peers.get(sender_public_key_bytes)
-                if peer is None:
-                    continue
-                try:
-                    ping = Ping.from_bytes(message.content)
-                except Exception as exc:
-                    print(f"Error decoding ping: {exc}")
-                    continue
-
-                peer.timestamp = datetime.now(timezone.utc)
-                peer.latest_block = ping.latest_block
-
-                validation_route = node.validation_route
-                if validation_route is None:
-                    continue
-                if ping.is_validator:
-                    try:
-                        validation_route.add_peer(sender_public_key_bytes)
-                    except Exception:
-                        pass
-                else:
-                    try:
-                        validation_route.remove_peer(sender_public_key_bytes)
-                    except Exception:
-                        pass
-            case MessageTopic.OBJECT_REQUEST:
-                pass
-            case MessageTopic.OBJECT_RESPONSE:
-                pass
-            case MessageTopic.ROUTE_REQUEST:
-                pass
-            case MessageTopic.ROUTE_RESPONSE:
-                pass
-            case MessageTopic.TRANSACTION:
-                if node.validation_secret_key is None:
-                    continue
-                node._validation_transaction_queue.put(message.content)
-
-            case MessageTopic.STORAGE_REQUEST:
-                payload = message.content
-                if len(payload) < 32:
-                    continue
-
-                atom_id = payload[:32]
-                provider_bytes = payload[32:]
-                if not provider_bytes:
-                    continue
-
-                try:
-                    provider_str = provider_bytes.decode("utf-8")
-                except UnicodeDecodeError:
-                    continue
-
-                try:
-                    host, port = addr[0], int(addr[1])
-                except Exception:
-                    continue
-                address_key = (host, port)
-                sender_key_bytes = node.addresses.get(address_key)
-                if sender_key_bytes is None:
-                    continue
-
-                try:
-                    local_key_bytes = node.relay_public_key.public_bytes(
-                        encoding=serialization.Encoding.Raw,
-                        format=serialization.PublicFormat.Raw,
-                    )
-                except Exception:
-                    continue
-
-                def xor_distance(target: bytes, key: bytes) -> int:
-                    return int.from_bytes(
-                        bytes(a ^ b for a, b in zip(target, key)),
-                        byteorder="big",
-                        signed=False,
-                    )
-
-                self_distance = xor_distance(atom_id, local_key_bytes)
-
-                try:
-                    closest_peer = node.peer_route.closest_peer_for_hash(atom_id)
-                except Exception:
-                    closest_peer = None
-
-                if (
-                    closest_peer is not None
-                    and closest_peer.public_key_bytes != sender_key_bytes
-                ):
-                    closest_distance = xor_distance(atom_id, closest_peer.public_key_bytes)
-                    if closest_distance < self_distance:
-                        target_addr = closest_peer.address
-                        if target_addr is not None and target_addr != addr:
-                            node.outgoing_queue.put((message.to_bytes(), target_addr))
-                            continue
-
-                node.storage_index[atom_id] = provider_str.strip()
-            
-            case _:
-                continue
-
-
-def populate_incoming_messages(node: "Node") -> None:
-    """Receive UDP packets and feed the incoming queue (placeholder)."""
-    while True:
-        try:
-            data, addr = node.incoming_socket.recvfrom(4096)
-            node.incoming_queue.put((data, addr))
-        except Exception as exc:
-            print(f"Error populating incoming queue: {exc}")
-
-def communication_setup(node: "Node", config: dict):
-    node.use_ipv6              = config.get('use_ipv6', False)
-
-    # key loading
-    node.relay_secret_key      = load_x25519(config.get('relay_secret_key'))
-    node.validation_secret_key = load_ed25519(config.get('validation_secret_key'))
-
-    # derive pubs + routes
-    node.relay_public_key      = node.relay_secret_key.public_key()
-    node.validation_public_key = (
-        node.validation_secret_key.public_key().public_bytes(
-            encoding=serialization.Encoding.Raw,
-            format=serialization.PublicFormat.Raw,
-        )
-        if node.validation_secret_key
-        else None
-    )
-    node.peer_route, node.validation_route = make_routes(
-        node.relay_public_key,
-        node.validation_secret_key
-    )
-
-    # sockets + queues + threads
-    incoming_port = config.get('incoming_port', 7373)
-    fam = socket.AF_INET6 if node.use_ipv6 else socket.AF_INET
-    node.incoming_socket = socket.socket(fam, socket.SOCK_DGRAM)
-    if node.use_ipv6:
-        node.incoming_socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
-    node.incoming_socket.bind(("::" if node.use_ipv6 else "0.0.0.0", incoming_port or 0))
-    node.incoming_port = node.incoming_socket.getsockname()[1]
-    node.incoming_queue = Queue()
-    node.incoming_populate_thread = threading.Thread(
-        target=populate_incoming_messages,
-        args=(node,),
-        daemon=True,
-    )
-    node.incoming_process_thread = threading.Thread(
-        target=process_incoming_messages,
-        args=(node,),
-        daemon=True,
-    )
-    node.incoming_populate_thread.start()
-    node.incoming_process_thread.start()
-
-    (node.outgoing_socket,
-        node.outgoing_queue,
-        node.outgoing_thread
-    ) = setup_outgoing(node.use_ipv6)
-
-    # other workers & maps
-    node.object_request_queue = Queue()
-    node.peer_manager_thread  = threading.Thread(
-        target=node._relay_peer_manager,
-        daemon=True
-    )
-    node.peer_manager_thread.start()
-
-    node.peers, node.addresses = {}, {} # peers: Dict[bytes,Peer], addresses: Dict[(str,int),bytes]
-    latest_hash = getattr(node, "latest_block_hash", None)
-    if not isinstance(latest_hash, (bytes, bytearray)) or len(latest_hash) != 32:
-        node.latest_block_hash = bytes(32)
-    else:
-        node.latest_block_hash = bytes(latest_hash)
-
-    # bootstrap pings
-    for addr in config.get('bootstrap', []):
-        try:
-            host, port = address_str_to_host_and_port(addr)  # type: ignore[arg-type]
-        except Exception:
-            continue
-
-        handshake_message = Message(handshake=True, sender=node.relay_public_key)
-        
-        node.outgoing_queue.put((handshake_message.to_bytes(), (host, port)))

astreum/_consensus/__init__.py

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

astreum/_consensus/account.py

@@ -1,95 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any, List, Optional, Tuple
-
-from .._storage.atom import Atom, ZERO32
-from .._storage.patricia import PatriciaTrie
-from ..utils.integer import bytes_to_int, int_to_bytes
-
-
-@dataclass
-class Account:
-    balance: int
-    code: bytes
-    counter: int
-    data_hash: bytes
-    data: PatriciaTrie
-    hash: bytes = ZERO32
-    body_hash: bytes = ZERO32
-    atoms: List[Atom] = field(default_factory=list)
-
-    @classmethod
-    def create(cls, balance: int = 0, data_hash: bytes = ZERO32, code: bytes = ZERO32, counter: int = 0) -> "Account":
-        account = cls(
-            balance=int(balance),
-            code=bytes(code),
-            counter=int(counter),
-            data_hash=bytes(data_hash),
-            data=PatriciaTrie(root_hash=bytes(data_hash)),
-        )
-        account.to_atom()
-        return account
-
-    @classmethod
-    def from_atom(cls, node: Any, account_id: bytes) -> "Account":
-        storage_get = node.storage_get
-
-        type_atom = storage_get(account_id)
-        if type_atom is None or type_atom.data != b"account":
-            raise ValueError("not an account (type mismatch)")
-
-        def _read_atom(atom_id: Optional[bytes]) -> Optional[Atom]:
-            if not atom_id or atom_id == ZERO32:
-                return None
-            return storage_get(atom_id)
-
-        balance_atom = _read_atom(type_atom.next)
-        if balance_atom is None:
-            raise ValueError("malformed account (balance missing)")
-
-        code_atom = _read_atom(balance_atom.next)
-        if code_atom is None:
-            raise ValueError("malformed account (code missing)")
-
-        counter_atom = _read_atom(code_atom.next)
-        if counter_atom is None:
-            raise ValueError("malformed account (counter missing)")
-
-        data_atom = _read_atom(counter_atom.next)
-        if data_atom is None:
-            raise ValueError("malformed account (data missing)")
-
-        account = cls.create(
-            balance=bytes_to_int(balance_atom.data),
-            data_hash=data_atom.data,
-            counter=bytes_to_int(counter_atom.data),
-            code=code_atom.data,
-        )
-        if account.hash != account_id:
-            raise ValueError("account hash mismatch while decoding")
-        return account
-
-    def to_atom(self) -> Tuple[bytes, List[Atom]]:
-        # Build a single forward chain: account -> balance -> code -> counter -> data.
-        data_atom = Atom.from_data(data=bytes(self.data_hash))
-        counter_atom = Atom.from_data(
-            data=int_to_bytes(self.counter),
-            next_hash=data_atom.object_id(),
-        )
-        code_atom = Atom.from_data(
-            data=bytes(self.code),
-            next_hash=counter_atom.object_id(),
-        )
-        balance_atom = Atom.from_data(
-            data=int_to_bytes(self.balance),
-            next_hash=code_atom.object_id(),
-        )
-        type_atom = Atom.from_data(data=b"account", next_hash=balance_atom.object_id())
-
-        atoms = [data_atom, counter_atom, code_atom, balance_atom, type_atom]
-        account_hash = type_atom.object_id()
-        self.hash = account_hash
-        self.body_hash = account_hash
-        self.atoms = atoms
-        return account_hash, list(atoms)

astreum/_consensus/accounts.py

@@ -1,38 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Dict, Optional
-
-from .._storage.patricia import PatriciaTrie
-from .account import Account
-
-
-class Accounts:
-    def __init__(
-        self,
-        root_hash: Optional[bytes] = None,
-    ) -> None:
-        self._trie = PatriciaTrie(root_hash=root_hash)
-        self._cache: Dict[bytes, Account] = {}
-
-    @property
-    def root_hash(self) -> Optional[bytes]:
-        return self._trie.root_hash
-
-    def get_account(self, address: bytes, node: Optional[Any] = None) -> Optional[Account]:
-        cached = self._cache.get(address)
-        if cached is not None:
-            return cached
-
-        if node is None:
-            raise ValueError("Accounts requires a node reference for trie access")
-
-        account_id: Optional[bytes] = self._trie.get(node, address)
-        if account_id is None:
-            return None
-
-        account = Account.from_atom(node, account_id)
-        self._cache[address] = account
-        return account
-
-    def set_account(self, address: bytes, account: Account) -> None:
-        self._cache[address] = account