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

astreum/utils/logging.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+import atexit
+import inspect
+import gzip
+import json
+import logging
+import logging.handlers
+import os
+import pathlib
+import platform
+import queue
+import shutil
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+from blake3 import blake3
+
+# Fixed identity for all loggers in this library
+_ORG_NAME = "Astreum"
+_PRODUCT_NAME = "lib-py"
+
+
+def _safe_path(path_str: str) -> Optional[pathlib.Path]:
+    try:
+        return pathlib.Path(path_str).resolve()
+    except Exception:
+        try:
+            return pathlib.Path(path_str).absolute()
+        except Exception:
+            return None
+
+
+def _hash_path(path: pathlib.Path) -> str:
+    try:
+        data = str(path).encode("utf-8", errors="ignore")
+    except Exception:
+        data = repr(path).encode("utf-8", errors="ignore")
+    return blake3(data).hexdigest()
+
+
+def _find_caller_path() -> pathlib.Path:
+    stack = inspect.stack()
+    candidates: list[pathlib.Path] = []
+    for frame_info in stack[2:]:
+        filename = frame_info.filename
+        if not filename:
+            continue
+        path = _safe_path(filename)
+        if path is None:
+            continue
+        candidates.append(path)
+        if "astreum" not in path.parts:
+            return path
+
+    if candidates:
+        return candidates[0]
+    return pathlib.Path.cwd()
+
+
+def _derive_instance_id() -> str:
+    return _hash_path(_find_caller_path())[:16]
+
+
+def _log_root(org: str, product: str, instance_id: str) -> pathlib.Path:
+    """Resolve the base directory for logs using platform defaults."""
+    if platform.system() == "Windows":
+        base = os.getenv("LOCALAPPDATA") or str(pathlib.Path.home())
+        return pathlib.Path(base) / org / product / "logs" / instance_id
+
+    xdg_state = os.getenv("XDG_STATE_HOME")
+    base_path = pathlib.Path(xdg_state) if xdg_state else pathlib.Path.home() / ".local" / "state"
+    return base_path / org / product / "logs" / instance_id
+
+
+class JSONFormatter(logging.Formatter):
+    """Log record formatter that emits JSON objects per line."""
+
+    def format(self, record: logging.LogRecord) -> str:  # type: ignore[override]
+        payload: Dict[str, Any] = {
+            "ts": datetime.fromtimestamp(record.created, tz=timezone.utc).isoformat(),
+            "level": record.levelname,
+            "logger": record.name,
+            "msg": record.getMessage(),
+            "pid": record.process,
+            "thread": record.threadName,
+            "module": record.module,
+            "func": record.funcName,
+            "instance_id": getattr(record, "instance_id", None),
+        }
+
+        for key, value in record.__dict__.items():
+            if key in payload or key.startswith(("_", "msecs", "relativeCreated")):
+                continue
+            try:
+                json.dumps(value)
+            except Exception:
+                continue
+            payload[key] = value
+
+        return json.dumps(payload, ensure_ascii=False)
+
+
+def _gzip_rotator(src: str, dst: str) -> None:
+    """Rotate the log file by gzipping it and removing the original."""
+    with open(src, "rb") as source, gzip.open(f"{dst}.gz", "wb") as target:
+        shutil.copyfileobj(source, target)
+    os.remove(src)
+
+
+def _namer(default_name: str) -> str:
+    """Custom name for rotated logs: node-YYYY-MM-DD.log."""
+    path = pathlib.Path(default_name)
+    parent = path.parent
+    name = path.name
+    fragments = name.split(".log.")
+    if len(fragments) != 2:
+        return default_name
+    stem, date_part = fragments
+    return str(parent / f"{stem}-{date_part}.log")
+
+
+def _human_line(record: logging.LogRecord) -> str:
+    """Format a record as a concise human-readable line."""
+    dt = datetime.fromtimestamp(record.created, tz=timezone.utc)
+    stamp = f"{dt:%Y-%m-%d}-{dt:%S}-{dt:%M}"
+    return f"[{stamp}] [{record.levelname.lower()}] {record.getMessage()}"
+
+
+class HumanFormatter(logging.Formatter):
+    """Simple formatter for optional verbose console output."""
+
+    def format(self, record: logging.LogRecord) -> str:  # type: ignore[override]
+        return _human_line(record)
+
+
+def _shutdown_listener(listener: logging.handlers.QueueListener, handlers: list[logging.Handler]) -> None:
+    """Stop the queue listener and close handlers on interpreter exit."""
+    try:
+        listener.stop()
+    except Exception:
+        pass
+    finally:
+        for handler in handlers:
+            try:
+                handler.close()
+            except Exception:
+                pass
+
+
+def logging_setup(config: dict) -> logging.LoggerAdapter:
+    """Configure logging according to the runtime config and return an adapter."""
+    if config is None:
+        config = {}
+    elif not isinstance(config, dict):
+        config = dict(config)
+
+    org = _ORG_NAME
+    product = _PRODUCT_NAME
+    instance_id = _derive_instance_id()
+
+    retention_value = config.get("retention_days")
+    retention_days = int(retention_value) if retention_value is not None else 90
+
+    verbose = bool(config.get("verbose", False))
+
+    log_dir = _log_root(org, product, instance_id)
+    log_dir.mkdir(parents=True, exist_ok=True)
+
+    base_file = log_dir / "node.log"
+    file_handler = logging.handlers.TimedRotatingFileHandler(
+        filename=str(base_file),
+        when="midnight",
+        interval=1,
+        backupCount=max(retention_days, 0),
+        utc=True,
+        encoding="utf-8",
+        delay=True,
+    )
+    file_handler.setFormatter(JSONFormatter())
+    file_handler.rotator = _gzip_rotator
+    file_handler.namer = _namer
+
+    handler_list: list[logging.Handler] = [file_handler]
+
+    if verbose:
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.INFO)
+        console_handler.setFormatter(HumanFormatter())
+        handler_list.append(console_handler)
+
+    log_queue: queue.Queue[logging.LogRecord] = queue.Queue(-1)
+    queue_handler = logging.handlers.QueueHandler(log_queue)
+
+    base_logger = logging.getLogger(f"{product}.{instance_id}")
+    base_logger.setLevel(logging.INFO)
+    base_logger.handlers.clear()
+    base_logger.propagate = False
+    base_logger.addHandler(queue_handler)
+
+    listener = logging.handlers.QueueListener(
+        log_queue, *handler_list, respect_handler_level=True
+    )
+    listener.daemon = True
+    listener.start()
+    atexit.register(_shutdown_listener, listener, handler_list)
+
+    adapter = logging.LoggerAdapter(base_logger, {"instance_id": instance_id})
+    setattr(adapter, "_queue_listener", listener)
+    setattr(adapter, "_handlers", handler_list)
+
+    return adapter
+
+
+__all__ = [
+    "HumanFormatter",
+    "JSONFormatter",
+    "logging_setup",
+]

astreum-0.3.1.dist-info/METADATA

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: astreum
+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-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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pycryptodomex==3.21.0
+Requires-Dist: cryptography==44.0.2
+Requires-Dist: blake3==1.0.4
+Dynamic: license-file
+
+# lib
+
+Python library to interact with the Astreum blockchain and its virtual machine.
+
+[View on PyPI](https://pypi.org/project/astreum/)
+
+## Configuration
+
+When initializing an `astreum.Node`, pass a dictionary with any of the options below. Only the parameters you want to override need to be present – everything else falls back to its default.
+
+### Core Configuration
+
+| Parameter                   | Type       | Default        | Description                                                                                                                                                                      |
+| --------------------------- | ---------- | -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `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                                                                                             |
+| ------------------------ | ----------- | --------------------- | ------------------------------------------------------------------------------------------------------- |
+| `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.
+> If `validation_secret_key` is provided the node automatically joins the validation route too.
+
+### Example
+
+```python
+from astreum.node import Node
+
+config = {
+    "relay_secret_key": "ab…cd",             # optional – hex encoded
+    "validation_secret_key": "12…34",        # optional – validator
+    "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"
+    ]
+}
+
+node = Node(config)
+# … your code …
+```
+
+
+## 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
+
+import uuid
+from astreum import Node, Env, Expr
+
+# 1) Spin‑up a stand‑alone VM
+node = Node()
+
+# 2) Create an environment (simple manual setup)
+env_id = uuid.uuid4()
+node.environments[env_id] = Env()
+
+# 3) Build a function value using a low‑level stack body via `sk`.
+# Body does: $0 $1 add   (i.e., a + b)
+low_body = Expr.ListExpr([
+    Expr.Symbol("$0"),  # a (first arg)
+    Expr.Symbol("$1"),  # b (second arg)
+    Expr.Symbol("add"),
+])
+
+fn_body = Expr.ListExpr([
+    Expr.Symbol("a"),
+    Expr.Symbol("b"),
+    Expr.ListExpr([low_body, Expr.Symbol("sk")]),
+])
+
+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, "int.add", int_add_fn)
+
+# 5) Retrieve the function and call it with bytes 1 and 2
+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)
+
+# 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]
+```
+
+### Handling errors
+
+Both helpers raise `ParseError` (from `astreum.machine.error`) when something goes wrong:
+
+* Unterminated string literals are caught by `tokenize`.
+* Unexpected or missing parentheses are caught by `parse`.
+
+Catch the exception to provide developer‑friendly diagnostics:
+
+```python
+try:
+    tokens = tokenize(bad_source)
+    expr, _ = parse(tokens)
+except ParseError as e:
+    print("Parse failed:", e)
+```
+
+---
+
+
+## Logging
+
+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"]`.
+- 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.
+
+## Testing
+
+```bash
+python3 -m venv venv
+source venv/bin/activate
+pip install -e .
+python3 -m unittest discover -s tests
+```

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/peer.py

@@ -1,11 +0,0 @@
-from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
-from datetime import datetime, timezone
-
-class Peer:
-    shared_key: bytes
-    timestamp: datetime
-    latest_block: 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)

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,170 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any, Callable, List, Optional, Tuple
-
-from .._storage.atom import Atom, ZERO32
-
-
-def _int_to_be_bytes(value: int) -> bytes:
-    value = int(value)
-    if value < 0:
-        raise ValueError("account integers must be non-negative")
-    if value == 0:
-        return b"\x00"
-    size = (value.bit_length() + 7) // 8
-    return value.to_bytes(size, "big")
-
-
-def _be_bytes_to_int(data: Optional[bytes]) -> int:
-    if not data:
-        return 0
-    return int.from_bytes(data, "big")
-
-
-def _make_list(child_ids: List[bytes]) -> Tuple[bytes, List[Atom]]:
-    next_hash = ZERO32
-    elements: List[Atom] = []
-    for child_id in reversed(child_ids):
-        elem = Atom.from_data(data=child_id, next_hash=next_hash)
-        next_hash = elem.object_id()
-        elements.append(elem)
-    elements.reverse()
-    value_atom = Atom.from_data(
-        data=len(child_ids).to_bytes(8, "little"),
-        next_hash=next_hash,
-    )
-    type_atom = Atom.from_data(data=b"list", next_hash=value_atom.object_id())
-    atoms = elements + [value_atom, type_atom]
-    return type_atom.object_id(), atoms
-
-
-def _resolve_storage_get(source: Any) -> Callable[[bytes], Optional[Atom]]:
-    if callable(source):
-        return source
-    getter = getattr(source, "_local_get", None)
-    if callable(getter):
-        return getter
-    raise TypeError("Account.from_atom needs a callable storage getter or node with '_local_get'")
-
-
-def _read_list_entries(
-    storage_get: Callable[[bytes], Optional[Atom]],
-    start: bytes,
-) -> List[bytes]:
-    entries: List[bytes] = []
-    current = start if start and start != ZERO32 else b""
-    while current:
-        elem = storage_get(current)
-        if elem is None:
-            break
-        entries.append(elem.data)
-        nxt = elem.next
-        current = nxt if nxt and nxt != ZERO32 else b""
-    return entries
-
-
-@dataclass
-class Account:
-    _balance: int
-    _data: bytes
-    _nonce: int
-    hash: bytes = ZERO32
-    atoms: List[Atom] = field(default_factory=list)
-
-    @staticmethod
-    def _encode(balance: int, data: bytes, nonce: int) -> Tuple[bytes, List[Atom]]:
-        balance_atom = Atom.from_data(data=_int_to_be_bytes(balance))
-        data_atom = Atom.from_data(data=bytes(data))
-        nonce_atom = Atom.from_data(data=_int_to_be_bytes(nonce))
-
-        field_atoms = [balance_atom, data_atom, nonce_atom]
-        field_ids = [a.object_id() for a in field_atoms]
-
-        body_id, body_atoms = _make_list(field_ids)
-        type_atom = Atom.from_data(data=b"account", next_hash=body_id)
-        top_id, top_atoms = _make_list([type_atom.object_id(), body_id])
-
-        atoms = field_atoms + body_atoms + [type_atom] + top_atoms
-        return top_id, atoms
-
-    @classmethod
-    def create(cls, balance: int, data: bytes, nonce: int) -> "Account":
-        account_hash, atoms = cls._encode(balance, data, nonce)
-        return cls(
-            _balance=int(balance),
-            _data=bytes(data),
-            _nonce=int(nonce),
-            hash=account_hash,
-            atoms=atoms,
-        )
-
-    @classmethod
-    def from_atom(cls, source: Any, account_id: bytes) -> "Account":
-        storage_get = _resolve_storage_get(source)
-
-        outer_list = storage_get(account_id)
-        if outer_list is None or outer_list.data != b"list":
-            raise ValueError("not an account (outer list missing)")
-
-        outer_value = storage_get(outer_list.next)
-        if outer_value is None:
-            raise ValueError("malformed account (outer value missing)")
-
-        entries = _read_list_entries(storage_get, outer_value.next)
-        if len(entries) < 2:
-            raise ValueError("malformed account (type/body missing)")
-
-        type_atom_id, body_id = entries[0], entries[1]
-        type_atom = storage_get(type_atom_id)
-        if type_atom is None or type_atom.data != b"account":
-            raise ValueError("not an account (type mismatch)")
-
-        body_list = storage_get(body_id)
-        if body_list is None or body_list.data != b"list":
-            raise ValueError("malformed account body (type)")
-
-        body_value = storage_get(body_list.next)
-        if body_value is None:
-            raise ValueError("malformed account body (value)")
-
-        field_ids = _read_list_entries(storage_get, body_value.next)
-        if len(field_ids) < 3:
-            field_ids.extend([ZERO32] * (3 - len(field_ids)))
-
-        def _read_field(field_id: bytes) -> bytes:
-            if not field_id or field_id == ZERO32:
-                return b""
-            atom = storage_get(field_id)
-            return atom.data if atom is not None else b""
-
-        balance_bytes = _read_field(field_ids[0])
-        data_bytes = _read_field(field_ids[1])
-        nonce_bytes = _read_field(field_ids[2])
-
-        account = cls.create(
-            balance=_be_bytes_to_int(balance_bytes),
-            data=data_bytes,
-            nonce=_be_bytes_to_int(nonce_bytes),
-        )
-        if account.hash != account_id:
-            raise ValueError("account hash mismatch while decoding")
-        return account
-
-    def balance(self) -> int:
-        return self._balance
-
-    def data(self) -> bytes:
-        return self._data
-
-    def nonce(self) -> int:
-        return self._nonce
-
-    def body_hash(self) -> bytes:
-        return self.hash
-
-    def to_atom(self) -> Tuple[bytes, List[Atom]]:
-        account_hash, atoms = self._encode(self._balance, self._data, self._nonce)
-        self.hash = account_hash
-        self.atoms = atoms
-        return account_hash, list(atoms)