astreum 0.2.40__py3-none-any.whl → 0.2.42__py3-none-any.whl

astreum/utils/integer.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Optional, Union
+
+ByteLike = Union[bytes, bytearray, memoryview]
+
+
+def int_to_bytes(value: Optional[int]) -> bytes:
+    """Convert an integer to a little-endian byte string with minimal length."""
+    if value is None:
+        return b""
+    value = int(value)
+    if value == 0:
+        return b"\x00"
+    length = (value.bit_length() + 7) // 8
+    return value.to_bytes(length, "little", signed=False)
+
+
+def bytes_to_int(data: Optional[ByteLike]) -> int:
+    """Convert a little-endian byte string to an integer."""
+    if not data:
+        return 0
+    if isinstance(data, memoryview):
+        data = data.tobytes()
+    return int.from_bytes(bytes(data), "little", signed=False)

{astreum-0.2.40.dist-info → astreum-0.2.42.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.40
+Version: 0.2.42
 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

{astreum-0.2.40.dist-info → astreum-0.2.42.dist-info}/RECORD

@@ -1,7 +1,7 @@
 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=SuVm1b0QWl1FpDUaLRH1fiFYnXCrPs6qYeUQlPDae8w,38358
+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
@@ -9,14 +9,20 @@ astreum/_communication/ping.py,sha256=u_DQTZJsbMdYiDDqjdZDsLaN5na2m9WZjVeEM3zq9_
 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=3RnLg5wdUCb4l7yFAB5fjxH6drGfpcjMx7XaHepXdY4,285
-astreum/_consensus/block.py,sha256=fnDOAAmHx2gaqA3XHuP-gBEXNadJyVjICkpv1-n_FVo,12037
-astreum/_consensus/chain.py,sha256=jx5O3tjLQZUl81XFAK-AI0Wh3WQ0NrHle3GrwyBXX2Q,2730
-astreum/_consensus/fork.py,sha256=29r4jyVihy0Gyt4JzCgEEDbrip_BkwQUtOU8JlypdpA,3753
-astreum/_consensus/genesis.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-astreum/_consensus/receipt.py,sha256=dm01AgOG7SFyrHBbNB48_81t_gUZnHCNE4Ps874P7_k,5663
-astreum/_consensus/setup.py,sha256=gpTbbHRAAzRhaQWNlw5NCiFXlOrUOMx5OkCJv_kY5Io,8073
-astreum/_consensus/transaction.py,sha256=qg1ahHslIXU7YSa-rUGd2zsrsIA5phgcNrRRsAvyHig,5770
+astreum/_consensus/__init__.py,sha256=gOCpvnIeO17CGjUGr0odaKNvGEggmDRXfT5IuyrYtcM,376
+astreum/_consensus/account.py,sha256=XCBWRapmFMrLCzz0wLtuuIaDRyNN9IKyOGc4dEl8W0s,3294
+astreum/_consensus/accounts.py,sha256=zGq2BCMJPtD_lzcj4jqMzB2Foc3ptxXSPhc9zypB1T0,1106
+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=oED7AHw0fPJgMu0OmhbbikJcbItw_bxVBVU8RlB2rJM,4766
+astreum/_consensus/receipt.py,sha256=GPLspqVJHnyBr1cKmBoClsJyeEUecYmg3_acz4L4rRo,6031
+astreum/_consensus/setup.py,sha256=agwqfOemdLqE0Z1zrPV2XHVmZ9sAxp8Bh4k6e2u-t8w,2385
+astreum/_consensus/transaction.py,sha256=VRp06ExbjAebiPcTZEX7PH-zwjzy4CLcf5kclyooL1k,7475
+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
@@ -26,34 +32,23 @@ 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=w0O_jw74nGhO0hgxFHk0RmkCIgHXHweBEOVULi7_dhQ,3652
+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/lispeum/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-astreum/lispeum/environment.py,sha256=wolwt9psDl62scgjaVG0G59xlBs1AM4NPgryUbxzG_4,1220
-astreum/lispeum/expression.py,sha256=K8gFifDaHu394bs9qnpvP8tjeiymFGQpnDC_iW9nU4E,2379
-astreum/lispeum/parser.py,sha256=jQRzZYvBuSg8t_bxsbt1-WcHaR_LPveHNX7Qlxhaw-M,1165
-astreum/lispeum/tokenizer.py,sha256=J-I7MEd0r2ZoVqxvRPlu-Afe2ZdM0tKXXhf1R4SxYTo,1429
 astreum/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-astreum/models/account.py,sha256=sHujGSwtV13rvOGJ5LZXuMrJ4F9XUdvyuWKz-zJ9lkE,2986
-astreum/models/accounts.py,sha256=aFSEWlq6zRf65-KGAdNGqEJyNVY3fpKhx8y1vU6sgSc,1164
-astreum/models/block.py,sha256=XNuzLaYKGX9Mv_naqWATfPskpWmeBh6FYzo4TGimLwg,18120
+astreum/models/block.py,sha256=_dgas0zW9OLFV7C1Bo-laxa102klqpJrCAG3DnwQ51U,18092
 astreum/models/merkle.py,sha256=lvWJa9nmrBL0n_2h_uNqpB_9a5s5Hn1FceRLx0IZIVQ,6778
 astreum/models/patricia.py,sha256=ohmXrcaz7Ae561tyC4u4iPOkQPkKr8N0IWJek4upFIg,13392
-astreum/models/transaction.py,sha256=MkLL5YX18kIf9-O4LBaZ4eWjkXDAaYIrDcDehbDZoqg,3038
-astreum/relay/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-astreum/relay/peer.py,sha256=94rNkHfsvYfq-ijLDR9QQkEJZ1meMr17HsaNYDBB8kg,398
-astreum/relay/route.py,sha256=enWT_1260LJq-L-zK-jtacQ8LbZGquNO9yj-9IglSXE,1232
-astreum/relay/setup.py,sha256=ynvGaJdlDtw_f5LLiow2Wo7IRzUjvgk8eSr1Sv4_zTg,2090
 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.40.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.2.40.dist-info/METADATA,sha256=ctn855yZQ8DLk5ZA-TsVvqSUCGU9viV6XzDF95vl1Hs,6181
-astreum-0.2.40.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-astreum-0.2.40.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.2.40.dist-info/RECORD,,
+astreum/utils/integer.py,sha256=iQt-klWOYVghu_NOT341MmHbOle4FDT3by4PNKNXscg,736
+astreum-0.2.42.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.2.42.dist-info/METADATA,sha256=xb_Bi75R1izIliHmHZQiJ93TxWPn6l9Z9EiN4IqVTAc,6181
+astreum-0.2.42.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+astreum-0.2.42.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.2.42.dist-info/RECORD,,

astreum/lispeum/environment.py

@@ -1,40 +0,0 @@
-from typing import Dict, Optional
-import uuid
-
-from astreum.lispeum.expression import Expr
-
-
-class Env:
-    def __init__(
-        self,
-        data: Optional[Dict[str, Expr]] = None,
-        parent_id: Optional[uuid.UUID] = None,
-        max_exprs: Optional[int] = 8,
-    ):
-        self.data: Dict[str, Expr] = data if data is not None else {}
-        self.parent_id: Optional[uuid.UUID] = parent_id
-        self.max_exprs: Optional[int] = max_exprs
-
-    def put(self, name: str, value: Expr) -> None:
-        if (
-            self.max_exprs is not None
-            and name not in self.data
-            and len(self.data) >= self.max_exprs
-        ):
-            raise RuntimeError(
-                f"environment full: {len(self.data)} ≥ max_exprs={self.max_exprs}"
-            )
-        self.data[name] = value
-
-    def get(self, name: str) -> Optional[Expr]:
-        return self.data.get(name)
-
-    def pop(self, name: str) -> Optional[Expr]:
-        return self.data.pop(name, None)
-
-    def __repr__(self) -> str:
-        return (
-            f"Env(size={len(self.data)}, "
-            f"max_exprs={self.max_exprs}, "
-            f"parent_id={self.parent_id})"
-        )

astreum/lispeum/expression.py

@@ -1,86 +0,0 @@
-
-from typing import List, Optional, Union
-
-
-class Expr:
-    class ListExpr:
-        def __init__(self, elements: List['Expr']):
-            self.elements = elements
-
-        def __eq__(self, other):
-            if not isinstance(other, Expr.ListExpr):
-                return NotImplemented
-            return self.elements == other.elements
-
-        def __ne__(self, other):
-            return not self.__eq__(other)
-
-        @property
-        def value(self):
-            inner = " ".join(str(e) for e in self.elements)
-            return f"({inner})"
-
-
-        def __repr__(self):
-            if not self.elements:
-                return "()"
-            
-            inner = " ".join(str(e) for e in self.elements)
-            return f"({inner})"
-        
-        def __iter__(self):
-            return iter(self.elements)
-        
-        def __getitem__(self, index: Union[int, slice]):
-            return self.elements[index]
-
-        def __len__(self):
-            return len(self.elements)
-
-    class Symbol:
-        def __init__(self, value: str):
-            self.value = value
-
-        def __repr__(self):
-            return self.value
-
-    class Integer:
-        def __init__(self, value: int):
-            self.value = value
-
-        def __repr__(self):
-            return str(self.value)
-
-    class String:
-        def __init__(self, value: str):
-            self.value = value
-
-        def __repr__(self):
-            return f'"{self.value}"'
-        
-    class Boolean:
-        def __init__(self, value: bool):
-            self.value = value
-
-        def __repr__(self):
-            return "true" if self.value else "false"
-
-    class Function:
-        def __init__(self, params: List[str], body: 'Expr'):
-            self.params = params
-            self.body = body
-
-        def __repr__(self):
-            params_str = " ".join(self.params)
-            body_str = str(self.body)
-            return f"(fn ({params_str}) {body_str})"
-
-    class Error:
-        def __init__(self, message: str, origin: Optional['Expr'] = None):
-            self.message = message
-            self.origin  = origin
-
-        def __repr__(self):
-            if self.origin is None:
-                return f'(error "{self.message}")'
-            return f'(error "{self.message}" in {self.origin})'

astreum/lispeum/parser.py

@@ -1,41 +0,0 @@
-from typing import List, Tuple
-from ..node import Expr
-
-class ParseError(Exception):
-    pass
-
-def parse(tokens: List[str]) -> Tuple[Expr, List[str]]:
-    if not tokens:
-        raise ParseError("Unexpected end of input")
-
-    first_token, *rest = tokens
-
-    if first_token == '(':
-        if not rest:
-            raise ParseError("Expected token after '('")
-
-        list_items = []
-        inner_tokens = rest
-
-        while inner_tokens:
-            if inner_tokens[0] == ')':
-                return Expr.ListExpr(list_items), inner_tokens[1:]
-
-            expr, inner_tokens = parse(inner_tokens)
-            list_items.append(expr)
-
-        raise ParseError("Expected closing ')'")
-
-    elif first_token == ')':
-        raise ParseError("Unexpected closing parenthesis")
-
-    elif first_token.startswith('"') and first_token.endswith('"'):
-        string_content = first_token[1:-1]
-        return Expr.String(string_content), rest
-
-    else:
-        try:
-            number = int(first_token)
-            return Expr.Integer(number), rest
-        except ValueError:
-            return Expr.Symbol(first_token), rest

astreum/lispeum/tokenizer.py

@@ -1,52 +0,0 @@
-
-
-# Tokenizer function
-from typing import List
-
-class ParseError(Exception):
-    pass
-
-def tokenize(input: str) -> List[str]:
-    tokens = []
-    current_token = ""
-    in_string = False
-    escape = False
-
-    for char in input:
-        if in_string:
-            if escape:
-                current_token += char
-                escape = False
-            elif char == '\\':
-                escape = True
-            elif char == '"':
-                in_string = False
-                tokens.append(f'"{current_token}"')
-                current_token = ""
-            else:
-                current_token += char
-        else:
-            if char.isspace():
-                if current_token:
-                    tokens.append(current_token)
-                    current_token = ""
-            elif char == '(' or char == ')':
-                if current_token:
-                    tokens.append(current_token)
-                    current_token = ""
-                tokens.append(char)
-            elif char == '"':
-                if current_token:
-                    tokens.append(current_token)
-                    current_token = ""
-                in_string = True
-            else:
-                current_token += char
-
-    if in_string:
-        raise ParseError("Unterminated string literal")
-
-    if current_token:
-        tokens.append(current_token)
-
-    return tokens

astreum/models/account.py

@@ -1,91 +0,0 @@
-from __future__ import annotations
-
-from typing import Optional, Callable
-
-from .merkle import MerkleTree
-
-_FIELD_ORDER = ["balance", "data", "nonce"]
-_INT_FIELDS = {"balance", "nonce"}
-
-def _int_to_min_bytes(i: int) -> bytes:
-    length = (i.bit_length() + 7) // 8 or 1
-    return i.to_bytes(length, "big")
-
-class Account:
-    def __init__(
-        self,
-        body_hash: bytes,
-        *,
-        body_tree: Optional[MerkleTree] = None,
-        get_node_fn: Optional[Callable[[bytes], Optional[bytes]]] = None,
-    ) -> None:
-        self._body_hash = body_hash
-        self._body_tree = body_tree
-        self._balance: Optional[int] = None
-        self._data: Optional[bytes] = None
-        self._nonce: Optional[int] = None
-
-        if self._body_tree and get_node_fn:
-            self._body_tree._node_get = get_node_fn
-
-    @classmethod
-    def create(
-        cls,
-        balance: int,
-        data: bytes,
-        nonce: int,
-    ) -> Account:
-        """Build an Account body from explicit fields in alphabetical order."""
-        # prepare values dict
-        values = {"balance": balance, "data": data, "nonce": nonce}
-
-        # build leaves in alphabetical order
-        leaves: list[bytes] = []
-        for name in _FIELD_ORDER:
-            v = values[name]
-            if name in _INT_FIELDS:
-                leaves.append(_int_to_min_bytes(v))  # type: ignore[arg-type]
-            else:
-                leaves.append(v)
-
-        tree = MerkleTree.from_leaves(leaves)
-        return cls(tree.root_hash, body_tree=tree)
-
-    def body_hash(self) -> bytes:
-        """Return the Merkle root of the account body."""
-        return self._body_hash
-
-    def _require_tree(self) -> MerkleTree:
-        if not self._body_tree:
-            raise ValueError("Body tree unavailable for this Account")
-        return self._body_tree
-
-    def balance(self) -> int:
-        """Fetch & cache the `balance` field (leaf 0)."""
-        if self._balance is not None:
-            return self._balance
-        raw = self._require_tree().get(0)
-        if raw is None:
-            raise ValueError("Merkle leaf 0 (balance) missing")
-        self._balance = int.from_bytes(raw, "big")
-        return self._balance
-
-    def data(self) -> bytes:
-        """Fetch & cache the `data` field (leaf 1)."""
-        if self._data is not None:
-            return self._data
-        raw = self._require_tree().get(1)
-        if raw is None:
-            raise ValueError("Merkle leaf 1 (data) missing")
-        self._data = raw
-        return self._data
-
-    def nonce(self) -> int:
-        """Fetch & cache the `nonce` field (leaf 2)."""
-        if self._nonce is not None:
-            return self._nonce
-        raw = self._require_tree().get(2)
-        if raw is None:
-            raise ValueError("Merkle leaf 2 (nonce) missing")
-        self._nonce = int.from_bytes(raw, "big")
-        return self._nonce

astreum/models/accounts.py

@@ -1,34 +0,0 @@
-from __future__ import annotations
-from typing import Dict, Optional, Callable
-from .patricia import PatriciaTrie
-from .account import Account
-
-class Accounts:
-    def __init__(
-        self,
-        root_hash: Optional[bytes] = None,
-        global_get_fn: Optional[Callable[[bytes], Optional[bytes]]] = None,
-    ) -> None:
-        self._global_get_fn = global_get_fn
-        self._trie = PatriciaTrie(node_get=global_get_fn, 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) -> Optional[Account]:
-        if address in self._cache:
-            return self._cache[address]
-
-        body_hash: Optional[bytes] = self._trie.get(address)
-        if body_hash is None:
-            return None
-
-        acc = Account(body_hash, get_node_fn=self._global_get_fn)
-        self._cache[address] = acc
-        return acc
-
-    def set_account(self, address: bytes, account: Account) -> None:
-        self._cache[address] = account
-        self._trie.put(address, account.body_hash())

astreum/models/transaction.py

@@ -1,106 +0,0 @@
-from __future__ import annotations
-
-from typing import Dict, List, Optional, Union, Any, Callable
-
-from .merkle import MerkleTree
-from ..crypto import ed25519
-
-_FIELD_ORDER: List[str] = [
-    "amount",
-    "balance",
-    "fee",
-    "nonce",
-    "recipient_pk",
-    "sender_pk",
-]
-
-_INT_FIELDS = {"amount", "balance", "fee", "nonce"}
-
-def _int_to_min_bytes(i: int) -> bytes:
-    length = (i.bit_length() + 7) // 8 or 1
-    return i.to_bytes(length, "big")
-
-class Transaction:
-    # init
-    def __init__(
-        self,
-        tx_hash: bytes,
-        *,
-        tree: Optional[MerkleTree] = None,
-        global_get_fn: Optional[Callable[[bytes], Optional[bytes]]] = None,
-    ) -> None:
-        self._hash = tx_hash
-        self._tree = tree
-        self._field_cache: Dict[str, Union[int, bytes]] = {}
-
-        if self._tree and global_get_fn:
-            self._tree.global_get_fn = global_get_fn
-
-    @classmethod
-    def create(
-        cls,
-        *,
-        amount: int,
-        balance: int,
-        fee: int,
-        nonce: int,
-        recipient_pk: bytes,
-        sender_pk: bytes,
-    ) -> "Transaction":
-        vals: Dict[str, Any] = locals().copy()
-        leaves = [
-            vals[name] if isinstance(vals[name], bytes) else _int_to_min_bytes(vals[name])
-            for name in _FIELD_ORDER
-        ]
-
-        tree = MerkleTree.from_leaves(leaves)
-        return cls(tx_hash=tree.root_hash, tree=tree)
-
-    @property
-    def hash(self) -> bytes:
-        return self._hash
-
-    def _require_tree(self) -> MerkleTree:
-        if not self._tree:
-            raise ValueError("Merkle tree unavailable for this Transaction")
-        return self._tree
-
-    def _field(self, idx: int, name: str) -> Union[int, bytes]:
-        if name in self._field_cache:
-            return self._field_cache[name]
-
-        raw = self._require_tree().get(idx)
-        if raw is None:
-            raise ValueError(f"Leaf {idx} (‘{name}’) missing from Merkle tree")
-
-        value = int.from_bytes(raw, "big") if name in _INT_FIELDS else raw
-        self._field_cache[name] = value
-        return value
-
-    def get_amount(self) -> int:
-        return self._field(0, "amount")
-    
-    def get_balance(self) -> int:
-        return self._field(1, "balance")
-    
-    def get_fee(self) -> int:
-        return self._field(2, "fee")
-    
-    def get_nonce(self) -> int:
-        return self._field(3, "nonce")
-    
-    def get_recipient_pk(self) -> bytes:
-        return self._field(4, "recipient_pk")
-    
-    def get_sender_pk(self) -> bytes:
-        return self._field(5, "sender_pk")
-    
-    def sign(self, priv: ed25519.Ed25519PrivateKey) -> bytes:
-        return priv.sign(self.hash)
-
-    def verify_signature(self, sig: bytes, sender_pk: bytes) -> bool:
-        try:
-            ed25519.Ed25519PublicKey.from_public_bytes(sender_pk).verify(sig, self.hash)
-            return True
-        except Exception:
-            return False

astreum/relay/peer.py

@@ -1,9 +0,0 @@
-from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
-from datetime import datetime, timezone
-
-class Peer:
-    shared_key: bytes
-    timestamp: datetime
-    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/relay/route.py

@@ -1,25 +0,0 @@
-from typing import Dict, List
-from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
-
-class Route:
-    def __init__(self, relay_public_key: X25519PublicKey, bucket_size: int = 16):
-        self.relay_public_key_bytes = relay_public_key.public_bytes(encoding=Encoding.Raw, format=PublicFormat.Raw)
-        self.bucket_size = bucket_size
-        self.buckets: Dict[int, List[X25519PublicKey]] = {
-            i: [] for i in range(len(self.relay_public_key_bytes) * 8)
-        }
-        self.peers = {}
-
-    @staticmethod
-    def _matching_leading_bits(a: bytes, b: bytes) -> int:
-        for byte_index, (ba, bb) in enumerate(zip(a, b)):
-            diff = ba ^ bb
-            if diff:
-                return byte_index * 8 + (8 - diff.bit_length())
-        return len(a) * 8
-
-    def add_peer(self, peer_public_key: X25519PublicKey):
-        peer_public_key_bytes = peer_public_key.public_bytes(encoding=Encoding.Raw, format=PublicFormat.Raw)
-        bucket_idx = self._matching_leading_bits(self.relay_public_key_bytes, peer_public_key_bytes)
-        if len(self.buckets[bucket_idx]) < self.bucket_size:
-            self.buckets[bucket_idx].append(peer_public_key)  

astreum/relay/setup.py

@@ -1,58 +0,0 @@
-import socket, threading
-from queue import Queue
-from typing import Tuple, Optional
-from cryptography.hazmat.primitives.asymmetric import ed25519
-from cryptography.hazmat.primitives.asymmetric.x25519 import (
-    X25519PrivateKey,
-    X25519PublicKey,
-)
-from yourproject.routes import Route
-
-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_udp(
-    bind_port: int,
-    use_ipv6: bool
-) -> Tuple[socket.socket, int, Queue, threading.Thread, threading.Thread]:
-    fam  = socket.AF_INET6 if use_ipv6 else socket.AF_INET
-    sock = socket.socket(fam, socket.SOCK_DGRAM)
-    if use_ipv6:
-        sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
-    sock.bind(("::" if use_ipv6 else "0.0.0.0", bind_port or 0))
-    port = sock.getsockname()[1]
-
-    q    = Queue()
-    pop  = threading.Thread(target=lambda: None, daemon=True)
-    proc = threading.Thread(target=lambda: None, daemon=True)
-    pop.start(); proc.start()
-    return sock, port, q, pop, proc
-
-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