astreum 0.2.23__py3-none-any.whl → 0.2.25__py3-none-any.whl

astreum/crypto/wesolowski.py

@@ -109,7 +109,7 @@ def deserialize(data: bytes, D: int) -> QuadraticForm:
 
 # --- Public VDF API -----------------------------------------------------
 
-def generate(
+def vdf_generate(
     old_output: bytes,
     T: int,
     D: int
@@ -136,7 +136,7 @@ def generate(
     return y_bytes, proof_bytes
 
 
-def verify(
+def vdf_verify(
     old_output: bytes,
     new_output: bytes,
     proof: bytes,

astreum/models/block.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
+from threading import Thread
 from typing import List, Dict, Any, Optional, Union
 
+from astreum.crypto.wesolowski import vdf_generate
 from astreum.models.account import Account
 from astreum.models.accounts import Accounts
 from astreum.models.patricia import PatriciaTrie
+from astreum.models.transaction import Transaction
 from ..crypto import ed25519
 from .merkle import MerkleTree
 
@@ -21,83 +24,44 @@ class Block:
     def __init__(
         self,
         block_hash: bytes,
+        *,
+        number: Optional[int] = None,
+        prev_block_hash: Optional[bytes] = None,
+        timestamp: Optional[int] = None,
+        accounts_hash: Optional[bytes] = None,
+        accounts: Optional[Accounts] = None,
+        transaction_limit: Optional[int] = None,
+        transactions_total_fees: Optional[int] = None,
+        transactions_root_hash: Optional[bytes] = None,
+        transactions_count: Optional[int] = None,
+        delay_difficulty: Optional[int] = None,
+        delay_output: Optional[bytes] = None,
+        delay_proof: Optional[bytes] = None,
+        validator_pk: Optional[bytes] = None,
         body_tree: Optional[MerkleTree] = None,
         signature: Optional[bytes] = None,
-    ) -> None:
-        self._block_hash = block_hash
-        self._body_tree = body_tree
-        self._signature = signature
-        # store field names in alphabetical order for consistent indexing
-        self._field_names = [
-            "accounts_hash",
-            "delay_difficulty",
-            "delay_output",
-            "delay_proof",
-            "number",
-            "prev_block_hash",
-            "timestamp",
-            "transaction_limit",
-            "transactions_root_hash",
-            "transactions_total_fees",
-            "validator_pk",
-        ]
+    ):
+        self.hash = block_hash
+        self.number = number
+        self.prev_block_hash = prev_block_hash
+        self.timestamp = timestamp
+        self.accounts_hash = accounts_hash
+        self.accounts = accounts
+        self.transaction_limit = transaction_limit
+        self.transactions_total_fees = transactions_total_fees
+        self.transactions_root_hash = transactions_root_hash
+        self.transactions_count = transactions_count
+        self.delay_difficulty = delay_difficulty
+        self.delay_output = delay_output
+        self.delay_proof = delay_proof
+        self.validator_pk = validator_pk
+        self.body_tree = body_tree
+        self.signature = signature
 
     @property
     def hash(self) -> bytes:
-        """Return the block hash (Merkle root of body_root || signature)."""
         return self._block_hash
 
-    @classmethod
-    def create(
-        cls,
-        number: int,
-        prev_block_hash: bytes,
-        timestamp: int,
-        accounts_hash: bytes,
-        transactions_total_fees: int,
-        transaction_limit: int,
-        transactions_root_hash: bytes,
-        delay_difficulty: int,
-        delay_output: bytes,
-        delay_proof: bytes,
-        validator_pk: bytes,
-        signature: bytes,
-    ) -> Block:
-        """Build a new block by hashing the provided fields into Merkle trees."""
-        # map fields by name
-        field_map: Dict[str, Any] = {
-            "accounts_hash": accounts_hash,
-            "delay_difficulty": delay_difficulty,
-            "delay_output": delay_output,
-            "delay_proof": delay_proof,
-            "number": number,
-            "prev_block_hash": prev_block_hash,
-            "timestamp": timestamp,
-            "transaction_limit": transaction_limit,
-            "transactions_root_hash": transactions_root_hash,
-            "transactions_total_fees": transactions_total_fees,
-            "validator_pk": validator_pk,
-        }
-        
-        leaves: List[bytes] = []
-        for name in sorted(field_map):
-            v = field_map[name]
-            if isinstance(v, bytes):
-                leaf_bytes = v
-            elif isinstance(v, int):
-                length = (v.bit_length() + 7) // 8 or 1
-                leaf_bytes = v.to_bytes(length, "big")
-            else:
-                raise TypeError(f"Unsupported field type for '{name}': {type(v)}")
-            leaves.append(leaf_bytes)
-        
-        body_tree = MerkleTree.from_leaves(leaves)
-        body_root = body_tree.root_hash
-        top_tree = MerkleTree.from_leaves([body_root, signature])
-        block_hash = top_tree.root_hash
-
-        return cls(block_hash, body_tree, signature)
-
     def get_body_hash(self) -> bytes:
         """Return the Merkle root of the body fields."""
         if not self._body_tree:
@@ -168,3 +132,216 @@ class Block:
 
         # 5 . build and return the block
         return cls.create(**body_kwargs)
+
+    @classmethod
+    def build(
+        cls,
+        previous_block: "Block",
+        transactions: List[Transaction],
+        *,
+        validator_sk,                     # private key for signing
+        natural_rate: float = 0.618,
+    ) -> "Block":
+        TREASURY = b"\x11" * 32
+        BURN     = b"\x00" * 32
+
+        blk = cls(
+            block_hash=b"",
+            number=previous_block.number + 1,
+            prev_block_hash=previous_block.hash,
+            timestamp=previous_block.timestamp + 1,
+            accounts_hash=previous_block.accounts_hash,
+            transaction_limit=previous_block.transaction_limit,
+            transactions_count=0,
+            validator_pk=validator_sk.public_key().public_bytes(),
+        )
+
+        # ------------------ difficulty via natural_rate -----------------------
+        prev_bt   = previous_block.block_time or 0
+        prev_diff = previous_block.delay_difficulty or 1
+        if prev_bt <= 1:
+            blk.delay_difficulty = max(1, int(prev_diff / natural_rate))  # increase
+        else:
+            blk.delay_difficulty = max(1, int(prev_diff * natural_rate))  # decrease
+
+        # ------------------ launch VDF in background --------------------------
+        vdf_result: dict[str, bytes] = {}
+
+        def _vdf_worker():
+            y, p = vdf_generate(previous_block.delay_output, blk.delay_difficulty, -4)
+            vdf_result["y"] = y
+            vdf_result["p"] = p
+
+        Thread(target=_vdf_worker, daemon=True).start()
+
+        # ------------------ process transactions -----------------------------
+        for tx in transactions:
+            try:
+                blk.apply_tx(tx)
+            except ValueError:
+                break
+
+        # ------------------ split fees --------------------------------------
+        burn_amt   = blk.total_fees // 2
+        reward_amt = blk.total_fees - burn_amt
+
+        def _credit(addr: bytes, amt: int):
+            acc = blk.accounts.get_account(addr) or Account.create(0, b"", 0)
+            blk.accounts.set_account(addr, Account.create(acc.balance() + amt, acc.data(), acc.nonce()))
+
+        if burn_amt:
+            _credit(BURN, burn_amt)
+        if reward_amt:
+            _credit(blk.validator_pk, reward_amt)
+
+        # ------------------ update tx limit with natural_rate ---------------
+        prev_limit    = previous_block.transaction_limit
+        prev_tx_count = previous_block.transactions_count
+        grow_thr      = prev_limit * natural_rate
+        shrink_thr    = prev_tx_count * natural_rate
+
+        if prev_tx_count > grow_thr:
+            blk.transaction_limit = prev_tx_count
+        elif prev_tx_count < shrink_thr:
+            blk.transaction_limit = max(1, int(prev_limit * natural_rate))
+        else:
+            blk.transaction_limit = prev_limit
+
+        # ------------------ wait for VDF ------------------------------------
+        while "y" not in vdf_result:
+            pass
+        blk.delay_output = vdf_result["y"]
+        blk.delay_proof  = vdf_result["p"]
+
+        # ------------------ timing & roots ----------------------------------
+        blk.block_time = blk.timestamp - previous_block.timestamp
+        blk.accounts_hash = blk.accounts.root_hash
+        blk.transactions_root_hash = MerkleTree.from_leaves(blk.tx_hashes).root_hash
+        blk.transactions_total_fees = blk.total_fees
+
+        # ------------------ build full body root ----------------------------
+        body_fields = {
+            "accounts_hash":           blk.accounts_hash,
+            "block_time":              blk.block_time,
+            "delay_difficulty":        blk.delay_difficulty,
+            "delay_output":            blk.delay_output,
+            "delay_proof":             blk.delay_proof,
+            "number":                  blk.number,
+            "prev_block_hash":         blk.prev_block_hash,
+            "timestamp":               blk.timestamp,
+            "transaction_limit":       blk.transaction_limit,
+            "transactions_count":      blk.transactions_count,
+            "transactions_root_hash":  blk.transactions_root_hash,
+            "transactions_total_fees": blk.transactions_total_fees,
+            "validator_pk":            blk.validator_pk,
+        }
+
+        leaves: List[bytes] = []
+        for k in sorted(body_fields):
+            v = body_fields[k]
+            if isinstance(v, bytes):
+                leaves.append(v)
+            else:
+                leaves.append(int(v).to_bytes((v.bit_length() + 7) // 8 or 1, "big"))
+
+        body_root = MerkleTree.from_leaves(leaves).root_hash
+        blk.body_tree = MerkleTree.from_leaves([body_root])
+        blk.signature = validator_sk.sign(body_root)
+        blk.hash = MerkleTree.from_leaves([body_root, blk.signature]).root_hash
+
+        return blk
+
+    
+    def apply_tx(self, tx: Transaction) -> None:
+        # --- lazy state ----------------------------------------------------
+        if not hasattr(self, "accounts") or self.accounts is None:
+            self.accounts = Accounts(root_hash=self.accounts_hash)
+        if not hasattr(self, "total_fees"):
+            self.total_fees = 0
+            self.tx_hashes = []
+            self.transactions_count = 0
+
+        TREASURY = b"\x11" * 32
+        BURN     = b"\x00" * 32
+
+        # --- cap check -----------------------------------------------------
+        if self.transactions_count >= self.transaction_limit:
+            raise ValueError("block transaction limit reached")
+
+        # --- unpack tx -----------------------------------------------------
+        sender_pk  = tx.get_sender_pk()
+        recip_pk   = tx.get_recipient_pk()
+        amount     = tx.get_amount()
+        fee        = tx.get_fee()
+        nonce      = tx.get_nonce()
+
+        sender_acct = self.accounts.get_account(sender_pk)
+        if (sender_acct is None
+            or sender_acct.nonce() != nonce
+            or sender_acct.balance() < amount + fee):
+            raise ValueError("invalid or unaffordable transaction")
+
+        # --- debit sender --------------------------------------------------
+        self.accounts.set_account(
+            sender_pk,
+            Account.create(
+                balance=sender_acct.balance() - amount - fee,
+                data=sender_acct.data(),
+                nonce=sender_acct.nonce() + 1,
+            )
+        )
+
+        # --- destination handling -----------------------------------------
+        if recip_pk == TREASURY:
+            treasury = self.accounts.get_account(TREASURY)
+
+            trie = PatriciaTrie(node_get=None, root_hash=treasury.data())
+            stake_bytes = trie.get(sender_pk) or b""
+            current_stake = int.from_bytes(stake_bytes, "big") if stake_bytes else 0
+
+            if amount > 0:
+                # stake **deposit**
+                trie.put(sender_pk, (current_stake + amount).to_bytes(32, "big"))
+                new_treas_bal = treasury.balance() + amount
+            else:
+                # stake **withdrawal**
+                if current_stake == 0:
+                    raise ValueError("no stake to withdraw")
+                # move stake back to sender balance
+                sender_after = self.accounts.get_account(sender_pk)
+                self.accounts.set_account(
+                    sender_pk,
+                    Account.create(
+                        balance=sender_after.balance() + current_stake,
+                        data=sender_after.data(),
+                        nonce=sender_after.nonce(),
+                    )
+                )
+                trie.delete(sender_pk)
+                new_treas_bal = treasury.balance()  # treasury balance unchanged
+
+            # write back treasury with new trie root
+            self.accounts.set_account(
+                TREASURY,
+                Account.create(
+                    balance=new_treas_bal,
+                    data=trie.root_hash,
+                    nonce=treasury.nonce(),
+                )
+            )
+
+        else:
+            recip_acct = self.accounts.get_account(recip_pk) or Account.create(0, b"", 0)
+            self.accounts.set_account(
+                recip_pk,
+                Account.create(
+                    balance=recip_acct.balance() + amount,
+                    data=recip_acct.data(),
+                    nonce=recip_acct.nonce(),
+                )
+            )
+
+        # --- accumulate fee & record --------------------------------------
+        self.total_fees += fee
+        self.tx_hashes.append(tx.hash)
+        self.transactions_count += 1

{astreum-0.2.23.dist-info → astreum-0.2.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.23
+Version: 0.2.25
 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.23.dist-info → astreum-0.2.25.dist-info}/RECORD

@@ -4,7 +4,7 @@ astreum/node.py,sha256=dPloCXuDyIn3-KDqxlgl3jxsonJlFMLi_quwJRsoLC8,46259
 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=FDAX82L5cceR6DGTtUO57ZhcxpBNiskGrnLWnd_3BSw,4084
+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/parser.py,sha256=jQRzZYvBuSg8t_bxsbt1-WcHaR_LPveHNX7Qlxhaw-M,1165
@@ -12,12 +12,12 @@ astreum/lispeum/tokenizer.py,sha256=J-I7MEd0r2ZoVqxvRPlu-Afe2ZdM0tKXXhf1R4SxYTo,
 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=3OyAAqw853aLnnWogYdkxOg_WXNEsfn2g8jrFEip2aY,6141
+astreum/models/block.py,sha256=4slG6z6pZUyxQUu2on4c8nT24ztzJuQBZRje9KyRTXE,13840
 astreum/models/merkle.py,sha256=merV3rx2iRfzvglV6gNusrJf7OMbcVV854T-DUWCC64,6733
 astreum/models/patricia.py,sha256=ohmXrcaz7Ae561tyC4u4iPOkQPkKr8N0IWJek4upFIg,13392
 astreum/models/transaction.py,sha256=yBarvRK2ybMAHHEQPZpubGO7gms4U9k093xQGNQHQ4Q,3043
-astreum-0.2.23.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.2.23.dist-info/METADATA,sha256=itKxfzkJrO8JcpMVCW3nDA_8NdtdndEj9zKJaoT5GGc,5478
-astreum-0.2.23.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-astreum-0.2.23.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.2.23.dist-info/RECORD,,
+astreum-0.2.25.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.2.25.dist-info/METADATA,sha256=BqaRK8hea6p3iMUkin5gqzivjdOz16_alamM9jFkteQ,5478
+astreum-0.2.25.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+astreum-0.2.25.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.2.25.dist-info/RECORD,,