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

astreum/utils/config.py

@@ -0,0 +1,48 @@
+
+from pathlib import Path
+from typing import Dict
+
+DEFAULT_HOT_STORAGE_LIMIT = 1 << 30  # 1 GiB
+DEFAULT_COLD_STORAGE_LIMIT = 10 << 30  # 10 GiB
+
+
+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)
+    )
+    try:
+        config["hot_storage_default_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
+
+    return config

{astreum-0.2.61.dist-info → astreum-0.3.9.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.9
+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,15 +109,15 @@ 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")
-call = Expr.ListExpr([Expr.Byte(1), Expr.Byte(2), bound])
+bound = node.env_get(env_id, "int.add")
+call = Expr.ListExpr([Expr.Bytes(b"\x01"), Expr.Bytes(b"\x02"), bound])
 res  = node.high_eval(env_id, call)
 
 # sk returns a list of bytes; for 1+2 expect a single byte with value 3
-print([b.value for b in res.elements])  # [3]
+print([int.from_bytes(b.value, 'big', signed=True) for b in res.elements])  # [3]
 ```
 
 ### Handling errors

astreum-0.3.9.dist-info/RECORD

@@ -0,0 +1,71 @@
+astreum/__init__.py,sha256=GkEW_ReYore8_0nEOvPnZLUa3lO7CgMWu6LeEjrGXEk,325
+astreum/node.py,sha256=naKGkn97M3Khux3r8mZ81wsiAI6JFr4uhly4X_BspmU,2689
+astreum/communication/__init__.py,sha256=wNxzsAk8Fol9cGMPuVvY4etrrMqn3SjZq1dE82kFrxw,228
+astreum/communication/setup.py,sha256=We43HOZG0v18TZhEdkc8MWCvI9YvHw8s4fmauHEXDUc,5887
+astreum/communication/start.py,sha256=wxL1cgChebhnaeEaY9flS6qybo_cFW2-tcRvjLxC8Hw,1823
+astreum/communication/util.py,sha256=fS3u3giOOXmvN0_reb0oIaXsFESHAWz-bbAuzdzdGQ4,1575
+astreum/communication/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/communication/handlers/handshake.py,sha256=79Y5ei8RHg53WIwzP1eO4dpDYdKvhr1qrbWMECf9D-E,2781
+astreum/communication/handlers/object_request.py,sha256=n_ThJomdYXm6HPfkLMmCqRxO58xPCUOHXf1ddmG-OC8,7163
+astreum/communication/handlers/object_response.py,sha256=X5MfYxd_b4SfKq3129Fi29ZfLynWNRyhGuoISiMHy20,3959
+astreum/communication/handlers/ping.py,sha256=2fVynfVIsbWHtf7lpM6fTYWmeG0I1WSU3tmgCh9di7A,916
+astreum/communication/handlers/route_request.py,sha256=KrucRgiM_oFNmwt93bRzNpeVHFATq3uhlNjGJIvzu-c,2477
+astreum/communication/handlers/route_response.py,sha256=ZUKyXPpZzpVYKBgygMIlPjcmjrxi0s8M3COFfY5aO4A,1744
+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=834UyyErBGbZs4dxe_SWz3gnRGnvFyc-7XQPrdNvDFE,1669
+astreum/communication/models/ping.py,sha256=u_DQTZJsbMdYiDDqjdZDsLaN5na2m9WZjVeEM3zq9_Y,955
+astreum/communication/models/route.py,sha256=NdmnI1J1wFs2pkm6W0Kv-29JeqGiHcKlw4-esT5ZFLA,3797
+astreum/communication/processors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/communication/processors/incoming.py,sha256=10l6Az-Ul_2BvYpTXgPiL9bL0te1q3GB3aET0JednKE,3325
+astreum/communication/processors/outgoing.py,sha256=09nAeTzvo3jGWl3SLgIQr8vfmO_IvdDqSG7_ZKThYPk,593
+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=DM45Pw6JL5rew-KpcspINguH43ZUHr4v99tXjYqaEkE,2551
+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=u6HyxamMVJjYnPFPa_U95I2pN9UzHRQ-LOa7YYZT808,2453
+astreum/consensus/workers/validation.py,sha256=uBkZVduHtwz8hUwDf_gFDiY8TfFaoYj40jx-s-EzuEU,13358
+astreum/consensus/workers/verify.py,sha256=tBBrAHH8Xcg3uopmQSjT6iuZd1s-9FkLnJ_JgeW5HdU,3423
+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=_93r6DKkCwnaOKmVGSp8JBlUPZpKrA1GECqVnwLb9es,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=yYr9ktk-NWPL4EXwHz7ePvr9eNvfSBQe3yzRUz06yas,7675
+astreum/machine/models/meter.py,sha256=5q2PFW7_jmgKVM1-vwE4RRjMfPEthUA4iu1CwR-Axws,505
+astreum/storage/__init__.py,sha256=Flk6WXT2xGFHWWJiZHK3O5OpjoLTOFMqqIiJTtD58kY,111
+astreum/storage/requests.py,sha256=q_rxG_k7POth93HmsUTCLSyNw-4EdFqqNExhIwm7Q0g,818
+astreum/storage/setup.py,sha256=fnDZCxVskOAPDl-oTwq-iLiRCD3CKHOEgI4LALNJQWI,612
+astreum/storage/actions/get.py,sha256=yf1HMYPMxRXTbZbSoe8JI6C4eWkcbScFQj-nGozBsCQ,6845
+astreum/storage/actions/set.py,sha256=8MvlZS3MFvLc-apDb6mucxt1JBxw82lxMVoa0sTvdo8,5751
+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/config.py,sha256=jiobdNFiF44BMmoifAG3feq57ZPIhjUG4FG71cn-kgY,1527
+astreum/utils/integer.py,sha256=iQt-klWOYVghu_NOT341MmHbOle4FDT3by4PNKNXscg,736
+astreum/utils/logging.py,sha256=mRDtWSCj8vKt58WGKLNSkK9Oa0graNVSoS8URby4Q9g,6684
+astreum-0.3.9.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.3.9.dist-info/METADATA,sha256=vlvV1wwS4GiKwUQhpEg3FqJ_I_5m4efioshBzwhs4bk,7766
+astreum-0.3.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+astreum-0.3.9.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.3.9.dist-info/RECORD,,

astreum/_communication/message.py

@@ -1,101 +0,0 @@
-from enum import IntEnum
-from typing import Optional
-from cryptography.hazmat.primitives import serialization
-from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PublicKey
-
-class MessageTopic(IntEnum):
-    PING = 0
-    OBJECT_REQUEST = 1
-    OBJECT_RESPONSE = 2
-    ROUTE_REQUEST = 3
-    ROUTE_RESPONSE = 4
-    TRANSACTION = 5
-    STORAGE_REQUEST = 6
-    
-
-class Message:
-    handshake: bool
-    sender: Optional[X25519PublicKey]
-
-    topic: Optional[MessageTopic]
-    content: bytes
-
-    def __init__(
-        self,
-        *,
-        handshake: bool = False,
-        sender: Optional[X25519PublicKey] = None,
-        topic: Optional[MessageTopic] = None,
-        content: bytes = b"",
-        body: Optional[bytes] = None,
-    ) -> None:
-        if body is not None:
-            if content and content != b"":
-                raise ValueError("specify only one of 'content' or 'body'")
-            content = body
-
-        self.handshake = handshake
-        self.sender = sender
-        self.topic = topic
-        self.content = content or b""
-
-        if self.handshake:
-            if self.sender is None:
-                raise ValueError("handshake Message requires a sender public key")
-            self.topic = None
-            self.content = b""
-        else:
-            if self.topic is None:
-                raise ValueError("non-handshake Message requires a topic")
-
-    def to_bytes(self):
-        if self.handshake:
-            # handshake byte (1) + raw public key bytes
-            return bytes([1]) + self.sender.public_bytes(
-                encoding=serialization.Encoding.Raw,
-                format=serialization.PublicFormat.Raw
-            )
-        else:
-            # normal message: 0 + topic + content
-            return bytes([0, self.topic.value]) + self.content
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> "Message":
-        if len(data) < 1:
-            raise ValueError("Cannot parse Message: no data")
-        flag = data[0]
-        # create empty instance
-        msg = cls.__new__(cls)
-
-        if flag == 1:
-            # handshake message: the rest is the peer’s public key
-            key_bytes = data[1:]
-            if not key_bytes:
-                raise ValueError("Handshake message missing sender public key bytes")
-            try:
-                sender = X25519PublicKey.from_public_bytes(key_bytes)
-            except ValueError:
-                raise ValueError("Invalid public key bytes")
-            if sender is None:
-                raise ValueError("Handshake message missing sender public key")
-            msg.handshake = True
-            msg.sender = sender
-            msg.topic = None
-            msg.content = b''
-        elif flag == 0:
-            # normal message: next byte is topic, rest is content
-            if len(data) < 2:
-                raise ValueError("Cannot parse Message: missing topic byte")
-            topic_val = data[1]
-            try:
-                topic = MessageTopic(topic_val)
-            except ValueError:
-                raise ValueError(f"Unknown MessageTopic: {topic_val}")
-            msg.handshake = False
-            msg.sender = None
-            msg.topic = topic
-            msg.content = data[2:]
-        else:
-            raise ValueError(f"Invalid handshake flag: {flag}")
-
-        return msg

astreum/_communication/peer.py

@@ -1,23 +0,0 @@
-from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
-from cryptography.hazmat.primitives import serialization
-from datetime import datetime, timezone
-from typing import Optional, Tuple
-
-class Peer:
-    shared_key: bytes
-    timestamp: datetime
-    latest_block: bytes
-    address: Optional[Tuple[str, int]]
-    public_key: X25519PublicKey
-    public_key_bytes: bytes
-
-    def __init__(self, my_sec_key: X25519PrivateKey, peer_pub_key: X25519PublicKey):
-        self.shared_key = my_sec_key.exchange(peer_pub_key)
-        self.timestamp = datetime.now(timezone.utc)
-        self.latest_block = b""
-        self.address = None
-        self.public_key = peer_pub_key
-        self.public_key_bytes = peer_pub_key.public_bytes(
-            encoding=serialization.Encoding.Raw,
-            format=serialization.PublicFormat.Raw,
-        )