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

astreum/models/patricia.py

@@ -1,393 +0,0 @@
-import blake3
-from typing import Callable, Dict, List, Optional, Tuple
-from ..format import encode, decode
-
-class PatriciaNode:
-    """
-    A node in a compressed-key Patricia trie.
-
-    Attributes:
-        key_len (int): Number of bits in the `key` prefix that are meaningful.
-        key (bytes): The MSB-aligned bit prefix (zero-padded in last byte).
-        value (Optional[bytes]): Stored payload (None for internal nodes).
-        child_0 (Optional[bytes]): Hash pointer for next-bit == 0.
-        child_1 (Optional[bytes]): Hash pointer for next-bit == 1.
-    """
-
-    def __init__(
-        self,
-        key_len: int,
-        key: bytes,
-        value: Optional[bytes],
-        child_0: Optional[bytes],
-        child_1: Optional[bytes]
-    ):
-        self.key_len = key_len
-        self.key = key
-        self.value = value
-        self.child_0 = child_0
-        self.child_1 = child_1
-        self._hash: Optional[bytes] = None
-
-    def to_bytes(self) -> bytes:
-        """
-        Serialize node fields to bytes using the shared encode format.
-        - key_len in a single byte.
-        - None pointers/values as empty bytes.
-        """
-        key_len_b = self.key_len.to_bytes(1, "big")
-        val_b = self.value if self.value is not None else b""
-        c0_b = self.child_0 if self.child_0 is not None else b""
-        c1_b = self.child_1 if self.child_1 is not None else b""
-        return encode([key_len_b, self.key, val_b, c0_b, c1_b])
-
-    @classmethod
-    def from_bytes(cls, blob: bytes) -> "PatriciaNode":
-        """
-        Deserialize a blob produced by to_bytes() back into a PatriciaNode.
-        Empty bytes are converted back to None for value/children.
-        """
-        key_len_b, key, val_b, c0_b, c1_b = decode(blob)
-        key_len = key_len_b[0]
-        value = val_b if val_b else None
-        child_0 = c0_b if c0_b else None
-        child_1 = c1_b if c1_b else None
-        return cls(key_len, key, value, child_0, child_1)
-
-    def hash(self) -> bytes:
-        """
-        Compute and cache the BLAKE3 hash of this node's serialized form.
-        """
-        if self._hash is None:
-            self._hash = blake3.blake3(self.to_bytes()).digest()
-        return self._hash
-
-class PatriciaTrie:
-    """
-    A compressed-key Patricia trie supporting get and put.
-    """
-
-    def __init__(
-        self,
-        node_get: Callable[[bytes], Optional[bytes]],
-        root_hash: Optional[bytes] = None,
-    ) -> None:
-        """
-        :param node_get: function mapping node-hash -> serialized node bytes (or None)
-        :param root_hash: optional hash of existing root node
-        """
-        self._node_get = node_get
-        self.nodes: Dict[bytes, PatriciaNode] = {}
-        self.root_hash = root_hash
-
-    @staticmethod
-    def _bit(buf: bytes, idx: int) -> bool:
-        """
-        Return the bit at position `idx` (MSB-first) from `buf`.
-        """
-        byte_i, offset = divmod(idx, 8)
-        return ((buf[byte_i] >> (7 - offset)) & 1) == 1
-
-    @classmethod
-    def _match_prefix(
-        cls,
-        prefix: bytes,
-        prefix_len: int,
-        key: bytes,
-        key_bit_offset: int,
-    ) -> bool:
-        """
-        Check whether the `prefix_len` bits of `prefix` match
-        bits in `key` starting at `key_bit_offset`.
-        """
-        total_bits = len(key) * 8
-        if key_bit_offset + prefix_len > total_bits:
-            return False
-        for i in range(prefix_len):
-            if cls._bit(prefix, i) != cls._bit(key, key_bit_offset + i):
-                return False
-        return True
-
-    def _fetch(self, h: bytes) -> Optional[PatriciaNode]:
-        """
-        Fetch a node by hash, using in-memory cache then external node_get.
-        """
-        node = self.nodes.get(h)
-        if node is None:
-            raw = self._node_get(h)
-            if raw is None:
-                return None
-            node = PatriciaNode.from_bytes(raw)
-            self.nodes[h] = node
-        return node
-
-    def get(self, key: bytes) -> Optional[bytes]:
-        """
-        Return the stored value for `key`, or None if absent.
-        """
-        # Empty trie?
-        if self.root_hash is None:
-            return None
-
-        node = self._fetch(self.root_hash)
-        if node is None:
-            return None
-
-        key_pos = 0  # bit offset into key
-
-        while node is not None:
-            # 1) Check that this node's prefix matches the key here
-            if not self._match_prefix(node.key, node.key_len, key, key_pos):
-                return None
-            key_pos += node.key_len
-
-            # 2) If we've consumed all bits of the search key:
-            if key_pos == len(key) * 8:
-                # Return value only if this node actually stores one
-                return node.value
-
-            # 3) Decide which branch to follow via next bit
-            try:
-                next_bit = self._bit(key, key_pos)
-            except IndexError:
-                return None
-
-            child_hash = node.child_1 if next_bit else node.child_0
-            if child_hash is None:
-                return None  # dead end
-
-            # 4) Fetch child and continue descent
-            node = self._fetch(child_hash)
-            if node is None:
-                return None  # dangling pointer
-
-            key_pos += 1  # consumed routing bit
-
-        return None
-
-    def put(self, key: bytes, value: bytes) -> None:
-        """
-        Insert or update `key` with `value` in-place.
-        """
-        total_bits = len(key) * 8
-
-        # S1 – Empty trie → create root leaf
-        if self.root_hash is None:
-            leaf = self._make_node(key, total_bits, value, None, None)
-            self.root_hash = leaf.hash()
-            return
-
-        # S2 – traversal bookkeeping
-        stack: List[Tuple[PatriciaNode, bytes, int]] = []  # (parent, parent_hash, dir_bit)
-        node = self._fetch(self.root_hash)
-        assert node is not None
-        key_pos = 0
-
-        # S4 – main descent loop
-        while True:
-            # 4.1 – prefix mismatch? → split
-            if not self._match_prefix(node.key, node.key_len, key, key_pos):
-                self._split_and_insert(node, stack, key, key_pos, value)
-                return
-
-            # 4.2 – consume this prefix
-            key_pos += node.key_len
-
-            # 4.3 – matched entire key → update value
-            if key_pos == total_bits:
-                old_hash = node.hash()
-                node.value = value
-                self._invalidate_hash(node)
-                new_hash = node.hash()
-                if new_hash != old_hash:
-                    self.nodes.pop(old_hash, None)
-                self.nodes[new_hash] = node
-                self._bubble(stack, new_hash)
-                return
-
-            # 4.4 – routing bit
-            next_bit = self._bit(key, key_pos)
-            child_hash = node.child_1 if next_bit else node.child_0
-
-            # 4.6 – no child → easy append leaf
-            if child_hash is None:
-                self._append_leaf(node, next_bit, key, key_pos, value, stack)
-                return
-
-            # 4.7 – push current node onto stack
-            stack.append((node, node.hash(), int(next_bit)))
-
-            # 4.8 – fetch child and continue
-            node = self._fetch(child_hash)
-            if node is None:
-                # Dangling pointer: treat as missing child
-                parent, _, _ = stack[-1]
-                self._append_leaf(parent, next_bit, key, key_pos, value, stack[:-1])
-                return
-
-            key_pos += 1  # consumed routing bit
-
-    def _append_leaf(
-        self,
-        parent: PatriciaNode,
-        dir_bit: bool,
-        key: bytes,
-        key_pos: int,
-        value: bytes,
-        stack: List[Tuple[PatriciaNode, bytes, int]],
-    ) -> None:
-        tail_len = len(key) * 8 - (key_pos + 1)
-        tail_bits, tail_len = self._bit_slice(key, key_pos + 1, tail_len)
-        leaf = self._make_node(tail_bits, tail_len, value, None, None)
-
-        old_parent_hash = parent.hash()
-        
-        if dir_bit:
-            parent.child_1 = leaf.hash()
-        else:
-            parent.child_0 = leaf.hash()
-
-        self._invalidate_hash(parent)
-        new_parent_hash = parent.hash()
-        if new_parent_hash != old_parent_hash:
-            self.nodes.pop(old_parent_hash, None)
-        self.nodes[new_parent_hash] = parent
-        self._bubble(stack, new_parent_hash)
-
-
-    def _split_and_insert(
-        self,
-        node: PatriciaNode,
-        stack: List[Tuple[PatriciaNode, bytes, int]],
-        key: bytes,
-        key_pos: int,
-        value: bytes,
-    ) -> None:
-        # ➊—find longest-common-prefix (lcp) as before …
-        max_lcp = min(node.key_len, len(key) * 8 - key_pos)
-        lcp = 0
-        while lcp < max_lcp and self._bit(node.key, lcp) == self._bit(key, key_pos + lcp):
-            lcp += 1
-
-        # divergence bit values (taken **before** we mutate node.key)
-        old_div_bit = self._bit(node.key, lcp)
-        new_div_bit = self._bit(key, key_pos + lcp)
-
-        # ➋—internal node that holds the common prefix
-        common_bits, common_len = self._bit_slice(node.key, 0, lcp)
-        internal = self._make_node(common_bits, common_len, None, None, None)
-
-        # ➌—trim the *existing* node’s prefix **after** the divergence bit
-        old_suffix_bits, old_suffix_len = self._bit_slice(
-            node.key,
-            lcp + 1,                       # start *after* divergence bit
-            node.key_len - lcp - 1         # may be zero
-        )
-        old_node_hash = node.hash()
-
-        node.key = old_suffix_bits
-        node.key_len = old_suffix_len
-        self._invalidate_hash(node)
-        new_node_hash = node.hash()
-        if new_node_hash != old_node_hash:
-            self.nodes.pop(old_node_hash, None)
-        self.nodes[new_node_hash] = node
-
-        # ➍—new leaf for the key being inserted (unchanged)
-        new_tail_len = len(key) * 8 - (key_pos + lcp + 1)
-        new_tail_bits, _ = self._bit_slice(key, key_pos + lcp + 1, new_tail_len)
-        leaf = self._make_node(new_tail_bits, new_tail_len, value, None, None)
-
-        # ➎—hang the two children off the internal node
-        if old_div_bit:
-            internal.child_1 = new_node_hash
-            internal.child_0 = leaf.hash()
-        else:
-            internal.child_0 = new_node_hash
-            internal.child_1 = leaf.hash()
-
-        # ➏—rehash up to the root (unchanged)
-        self._invalidate_hash(internal)
-        internal_hash = internal.hash()
-        self.nodes[internal_hash] = internal
-
-        if not stack:
-            self.root_hash = internal_hash
-            return
-
-        parent, _, dir_bit = stack.pop()
-        if dir_bit == 0:
-            parent.child_0 = internal_hash
-        else:
-            parent.child_1 = internal_hash
-        self._invalidate_hash(parent)
-        self._bubble(stack, parent.hash())
-
-
-    def _make_node(
-        self,
-        prefix_bits: bytes,
-        prefix_len: int,
-        value: Optional[bytes],
-        child0: Optional[bytes],
-        child1: Optional[bytes],
-    ) -> PatriciaNode:
-        node = PatriciaNode(prefix_len, prefix_bits, value, child0, child1)
-        self.nodes[node.hash()] = node
-        return node
-
-    def _invalidate_hash(self, node: PatriciaNode) -> None:
-        """Clear cached hash so next .hash() recomputes."""
-        node._hash = None  # type: ignore
-
-    def _bubble(
-        self,
-        stack: List[Tuple[PatriciaNode, bytes, int]],
-        new_hash: bytes
-    ) -> None:
-        """
-        Propagate updated child-hash `new_hash` up the ancestor stack,
-        rebasing each parent's pointer, invalidating and re-hashing.
-        """
-        while stack:
-            parent, old_hash, dir_bit = stack.pop()
-
-            if dir_bit == 0:
-                parent.child_0 = new_hash
-            else:
-                parent.child_1 = new_hash
-
-            self._invalidate_hash(parent)
-            new_hash = parent.hash()
-            if new_hash != old_hash:
-                self.nodes.pop(old_hash, None)
-            self.nodes[new_hash] = parent
-            
-        self.root_hash = new_hash
-
-
-    def _bit_slice(
-        self,
-        buf: bytes,
-        start_bit: int,
-        length: int
-    ) -> tuple[bytes, int]:
-        """
-        Extract `length` bits from `buf` starting at `start_bit` (MSB-first),
-        returning (bytes, bit_len) with zero-padding.
-        """
-        if length == 0:
-            return b"", 0
-
-        total = int.from_bytes(buf, "big")
-        bits_in_buf = len(buf) * 8
-
-        # shift so slice ends at LSB
-        shift = bits_in_buf - (start_bit + length)
-        slice_int = (total >> shift) & ((1 << length) - 1)
-
-        # left-align to MSB of first byte
-        pad = (8 - (length % 8)) % 8
-        slice_int <<= pad
-        byte_len = (length + 7) // 8
-        return slice_int.to_bytes(byte_len, "big"), length

astreum/storage/object.py

@@ -1,68 +0,0 @@
-from enum import IntEnum
-
-class ObjectRequestType(IntEnum):
-    OBJECT_GET = 0
-    OBJECT_PUT = 1
-
-class ObjectRequest:
-    type: ObjectRequestType
-    data: bytes
-    hash: bytes
-
-    def __init__(self, type: ObjectRequestType, data: bytes, hash: bytes = None):
-        self.type = type
-        self.data = data
-        self.hash = hash
-
-    def to_bytes(self):
-        return [self.type.value] + self.hash + self.data
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> "ObjectRequest":
-        # need at least 1 byte for type + 32 bytes for hash
-        if len(data) < 1 + 32:
-            raise ValueError(f"Too short for ObjectRequest ({len(data)} bytes)")
-
-        type_val = data[0]
-        try:
-            req_type = ObjectRequestType(type_val)
-        except ValueError:
-            raise ValueError(f"Unknown ObjectRequestType: {type_val!r}")
-
-        hash_bytes = data[1:33]
-        payload    = data[33:]
-        return cls(req_type, payload, hash_bytes)
-
-class ObjectResponseType(IntEnum):
-    OBJECT_FOUND = 0
-    OBJECT_PROVIDER = 1
-    OBJECT_NEAREST_PEER = 2
-
-class ObjectResponse:
-    type: ObjectResponseType
-    data: bytes
-    hash: bytes
-
-    def __init__(self, type: ObjectResponseType, data: bytes, hash: bytes = None):
-        self.type = type
-        self.data = data
-        self.hash = hash
-
-    def to_bytes(self):
-        return [self.type.value] + self.hash + self.data
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> "ObjectResponse":
-        # need at least 1 byte for type + 32 bytes for hash
-        if len(data) < 1 + 32:
-            raise ValueError(f"Too short to be a valid ObjectResponse ({len(data)} bytes)")
-
-        type_val = data[0]
-        try:
-            resp_type = ObjectResponseType(type_val)
-        except ValueError:
-            raise ValueError(f"Unknown ObjectResponseType: {type_val}")
-
-        hash_bytes = data[1:33]
-        payload   = data[33:]
-        return cls(resp_type, payload, hash_bytes)

astreum-0.2.41.dist-info/METADATA

@@ -1,146 +0,0 @@
-Metadata-Version: 2.4
-Name: astreum
-Version: 0.2.41
-Summary: Python library to interact with the Astreum blockchain and its Lispeum 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
-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 Lispeum 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                                                                                                                                                                      |
-| --------------------------- | ---------- | -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `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.                                                                                                            |
-
-### 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) ]`. |
-
-> **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 = {
-    "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,
-    "incoming_port": 7373,
-    "use_ipv6": False,
-    "bootstrap": [
-        ("bootstrap.astreum.org", 7373),
-        ("127.0.0.1", 7374)
-    ]
-}
-
-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.
-
-```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, b"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])
-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)
-```
-
----
-
-## Testing
-
-```bash
-python3 -m venv venv
-source venv/bin/activate
-pip install -e .
-python3 -m unittest discover -s tests
-```

astreum-0.2.41.dist-info/RECORD

@@ -1,53 +0,0 @@
-astreum/__init__.py,sha256=9tzA27B_eG5wRF1SAWJIV7xTmCcR1QFc123b_cvFOa4,345
-astreum/_node.py,sha256=3fpfULVs3MrPBR-ymlvPyuZMi8lv0a8JBnxPb2oFOTU,2214
-astreum/format.py,sha256=X4tG5GGPweNCE54bHYkLFiuLTbmpy5upO_s1Cef-MGA,2711
-astreum/node.py,sha256=MmlK3jaANTMB3ZAxR8IaSc82OS9meJmVawYIVURADbg,39689
-astreum/_communication/__init__.py,sha256=XJui0yOcfAur4HKt-8sSRlwB-MSU1rchkuOAY-nKDOE,207
-astreum/_communication/message.py,sha256=zNjUnt1roJRHMEoiLkcA7VK_TsHXok8PYEF7KTCqKnQ,3303
-astreum/_communication/peer.py,sha256=DT2vJOzeLyyOj7vTDQ1u1lF5Vc7Epj0Hhie-YfDrzfA,425
-astreum/_communication/ping.py,sha256=u_DQTZJsbMdYiDDqjdZDsLaN5na2m9WZjVeEM3zq9_Y,955
-astreum/_communication/route.py,sha256=fbVXY0xF3O-k7dY9TuCsr6_XxD3m7Cb9ugVacQZ6GSk,2490
-astreum/_communication/setup.py,sha256=TzXpc8dajV31BJhHQMMcb5UdaFrxb1xlYSj58vc_5mg,9072
-astreum/_communication/util.py,sha256=bJ3td3naDzmCelAJQpLwiDMoRBkijQl9YLROjsWyOrI,1256
-astreum/_consensus/__init__.py,sha256=gOCpvnIeO17CGjUGr0odaKNvGEggmDRXfT5IuyrYtcM,376
-astreum/_consensus/account.py,sha256=d95h5c8kvmLD4CCyGRvaTJRQK7AESKrqDG8bCdbZOKg,5614
-astreum/_consensus/accounts.py,sha256=NaLKDafsfq9SgFMtrYQpvAO7o0XbEwAIRhFl0dkY_Dk,2277
-astreum/_consensus/block.py,sha256=v6U2y8br9PVKGn0Q8fLVOtEODlXayPtEd_Wqprem_TU,12358
-astreum/_consensus/chain.py,sha256=WwUeLrdg7uj--ZsUxse6xFlzO2QeQQggyKSL49KhfU0,2768
-astreum/_consensus/fork.py,sha256=dK5DtT9hWCj_rQs6MS1c1bcGBbkgVTBPIOudYbqS9vw,3825
-astreum/_consensus/genesis.py,sha256=Xe9LA58cBz_IoutSJrtjeGDuFo0W-MVrWMkSdEwAVog,4760
-astreum/_consensus/receipt.py,sha256=GPLspqVJHnyBr1cKmBoClsJyeEUecYmg3_acz4L4rRo,6031
-astreum/_consensus/setup.py,sha256=agwqfOemdLqE0Z1zrPV2XHVmZ9sAxp8Bh4k6e2u-t8w,2385
-astreum/_consensus/transaction.py,sha256=LK4oDe9EepOfzLxeXc19fEFDBoxY-aj_v-nsuRyET8g,6490
-astreum/_consensus/workers/__init__.py,sha256=bS5FjbevbIR5FHbVGnT4Jli17VIld_5auemRw4CaHFU,278
-astreum/_consensus/workers/discovery.py,sha256=X1yjKGjLSApMJ9mgWbnc7N21ALD09khDf-in-M45Mis,1683
-astreum/_consensus/workers/validation.py,sha256=WcHLOs2NLMTrJpErghBXWeW2aqtX3-xGPo-HcySdEZ8,4814
-astreum/_consensus/workers/verify.py,sha256=uqmf2UICj_eBFeGDpGyzKQLtz9qeCbOtz5euwNqkZmw,1924
-astreum/_lispeum/__init__.py,sha256=LAy2Z-gBBQlByBHRGUKaaQrOB7QzFEEyGRtInmwTpfU,304
-astreum/_lispeum/environment.py,sha256=pJ0rjp9GoQxHhDiPIVei0jP7dZ_Pznso2O_tpp94-Ik,328
-astreum/_lispeum/expression.py,sha256=io8tbCer_1TJee77yRbcNI5q-DPFGa8xZiC80tGvRRQ,1063
-astreum/_lispeum/high_evaluation.py,sha256=7MwIeVZMPumYvKXn6Lkn-GrZhRNB6MjnUUWdiYT7Ei0,7952
-astreum/_lispeum/low_evaluation.py,sha256=HgyCSAmL5K5SKq3Xw_BtbTZZUJbMg4-bVZW-A12glQ0,4373
-astreum/_lispeum/meter.py,sha256=5q2PFW7_jmgKVM1-vwE4RRjMfPEthUA4iu1CwR-Axws,505
-astreum/_lispeum/parser.py,sha256=WOW3sSZWkIzPEy3fYTyl0lrtkMxHL9zRrNSYztPDemQ,2271
-astreum/_lispeum/tokenizer.py,sha256=P68uIj4aPKzjuCJ85jfzRi67QztpuXIOC1vvLQueBI4,552
-astreum/_storage/__init__.py,sha256=EmKZNAZmo3UVE3ekOOuckwFnBVjpa0Sy8Oxg72Lgdxc,53
-astreum/_storage/atom.py,sha256=YFjvfMhniInch13iaKGpw4CCxxgyWonniryb-Rfse4A,4177
-astreum/_storage/patricia.py,sha256=Eh8AO2_J8WCai4kyuML_0Jb_zntgGlq-VPljnSjss10,14851
-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/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-astreum/models/block.py,sha256=7qKUhOpL26NiiLDq_ff7mJCNrbxWb_9jPTtMtjemy3Y,18126
-astreum/models/merkle.py,sha256=lvWJa9nmrBL0n_2h_uNqpB_9a5s5Hn1FceRLx0IZIVQ,6778
-astreum/models/patricia.py,sha256=ohmXrcaz7Ae561tyC4u4iPOkQPkKr8N0IWJek4upFIg,13392
-astreum/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-astreum/storage/object.py,sha256=knFlvw_tpcC4twSu1DGNpHX31wlANN8E5dgEqIfU--Q,2041
-astreum/storage/setup.py,sha256=1-9ztEFI_BvRDvAA0lAn4mFya8iq65THTArlj--M3Hg,626
-astreum-0.2.41.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.2.41.dist-info/METADATA,sha256=03v5FuUofHssnDaviuCFvqWB1p3hz6lqvhM1t9HFhas,6181
-astreum-0.2.41.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-astreum-0.2.41.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.2.41.dist-info/RECORD,,