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

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 

astreum-0.2.29.dist-info/RECORD

@@ -1,33 +0,0 @@
-astreum/__init__.py,sha256=y2Ok3EY_FstcmlVASr80lGR_0w-dH-SXDCCQFmL6uwA,28
-astreum/format.py,sha256=X4tG5GGPweNCE54bHYkLFiuLTbmpy5upO_s1Cef-MGA,2711
-astreum/node.py,sha256=OhiApRqQcPc6-CWbk2NeKdOiXQapy0mbl3uLK_xjmYU,28971
-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=K-NDzIjtIsXzC9X7lnYvlvIaVxjFcY7WNsgLIE3DH3U,58
-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=-5j7uO0woVtNi0h52__e7AxpDQSVhzKUhr6Qc-2xZsE,17870
-astreum/models/merkle.py,sha256=lvWJa9nmrBL0n_2h_uNqpB_9a5s5Hn1FceRLx0IZIVQ,6778
-astreum/models/message.py,sha256=vv8yx-ndVYjCmPM4gXRVMToCTlKY_mflPu0uKsb9iiE,2117
-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.29.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.2.29.dist-info/METADATA,sha256=JSIc8N98KW4Wmm89uMMFxyJKiEFxIU-zGRjIXf9JL24,5478
-astreum-0.2.29.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-astreum-0.2.29.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.2.29.dist-info/RECORD,,