astreum 0.2.24__py3-none-any.whl → 0.2.26__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,7 +1,9 @@
 from __future__ import annotations
 
+from threading import Thread
 from typing import List, Dict, Any, Optional, Union
 
+from astreum.crypto.wesolowski import vdf_generate, vdf_verify
 from astreum.models.account import Account
 from astreum.models.accounts import Accounts
 from astreum.models.patricia import PatriciaTrie
@@ -84,123 +86,162 @@ class Block:
             return int.from_bytes(leaf_bytes, "big")
         return leaf_bytes
 
-    def verify_block_signature(self) -> bool:
-        """Verify the block's Ed25519 signature against its body root."""
-        pub = ed25519.Ed25519PublicKey.from_public_bytes(
-            self.get_field("validator_pk")
-        )
-        try:
-            pub.verify(self.get_signature(), self.get_body_hash())
-            return True
-        except Exception:
-            return False
-
     @classmethod
     def genesis(cls, validator_addr: bytes) -> "Block":
-        # 1 . validator-stakes sub-trie
+        # 1. validator-stakes sub-trie
         stake_trie = PatriciaTrie()
         stake_trie.put(validator_addr, (1).to_bytes(32, "big"))
         stake_root = stake_trie.root_hash
 
-        # 2 . build the two Account bodies
-        validator_acct = Account.create(balance=0, data=b"",        nonce=0)
+        # 2. three Account bodies
+        validator_acct = Account.create(balance=0, data=b"", nonce=0)
         treasury_acct  = Account.create(balance=1, data=stake_root, nonce=0)
+        burn_acct = Account.create(balance=0, data=b"", nonce=0)
 
-        # 3 . global Accounts structure
+        # 3. global Accounts structure
         accts = Accounts()
         accts.set_account(validator_addr, validator_acct)
         accts.set_account(b"\x11" * 32, treasury_acct)
+        accts.set_account(b"\x00" * 32, burn_acct)
         accounts_hash = accts.root_hash
 
-        # 4 . constant body fields for genesis
+        # 4. constant body fields for genesis
         body_kwargs = dict(
+            block_hash              = b"",
             number                  = 0,
             prev_block_hash         = b"\x00" * 32,
             timestamp               = 0,
+            block_time              = 0,
             accounts_hash           = accounts_hash,
+            accounts                = accts,
             transactions_total_fees = 0,
-            transaction_limit       = 0,
+            transaction_limit       = 1,
             transactions_root_hash  = b"\x00" * 32,
-            delay_difficulty        = 0,
+            transactions_count      = 0,
+            delay_difficulty        = 1,
             delay_output            = b"",
             delay_proof             = b"",
             validator_pk            = validator_addr,
             signature               = b"",
         )
 
-        # 5 . build and return the block
+        # 5. build and return the block
         return cls.create(**body_kwargs)
 
     @classmethod
     def build(
         cls,
         previous_block: "Block",
-        transactions: list[Transaction],
+        transactions: List[Transaction],
         *,
-        validator_pk: bytes,
+        validator_sk,
         natural_rate: float = 0.618,
     ) -> "Block":
         BURN     = b"\x00" * 32
 
-        # --- 0. create an empty block-in-progress, seeded with parent fields ----
         blk = cls(
-            block_hash=b"",                         # placeholder; set at the end
+            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(),
         )
 
-        # --- 1. apply up to transaction_limit txs -------------------------------
+        # ------------------ 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)                   # ← NEW single-line call
+                blk.apply_tx(tx)
             except ValueError:
-                break                              # stop at first invalid or cap reached
+                break
 
-        # --- 2. split fees after all txs ----------------------------------------
+        # ------------------ 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:
-            blk.accounts.set_account(
-                BURN,
-                Account.create(
-                    balance=(blk.accounts.get_account(BURN) or Account.create(0, b"", 0)).balance() + burn_amt,
-                    data=b"",
-                    nonce=0,
-                ),
-            )
+            _credit(BURN, burn_amt)
         if reward_amt:
-            blk.accounts.set_account(
-                validator_pk,
-                Account.create(
-                    balance=(blk.accounts.get_account(validator_pk) or Account.create(0, b"", 0)).balance() + reward_amt,
-                    data=b"",
-                    nonce=0,
-                ),
-            )
+            _credit(blk.validator_pk, reward_amt)
 
-        # --- 3. recalc tx-limit via prev metrics -------------------------------
+        # ------------------ update tx limit with natural_rate ---------------
         prev_limit    = previous_block.transaction_limit
         prev_tx_count = previous_block.transactions_count
-        threshold     = prev_limit * natural_rate
-        if prev_tx_count > threshold:
+        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 < threshold:
+        elif prev_tx_count < shrink_thr:
             blk.transaction_limit = max(1, int(prev_limit * natural_rate))
         else:
             blk.transaction_limit = prev_limit
 
-        # --- 4. finalise block hash & header roots ------------------------------
+        # ------------------ 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.hash = MerkleTree.from_leaves([
-            blk.transactions_root_hash,
-            blk.accounts_hash,
-            blk.total_fees.to_bytes(8, "big"),
-        ]).root_hash  # or your existing body-root/signing scheme
+        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
 
@@ -298,3 +339,94 @@ class Block:
         self.total_fees += fee
         self.tx_hashes.append(tx.hash)
         self.transactions_count += 1
+
+    def validate_block(self, remote_get_fn) -> bool:
+        NAT = 0.618
+        _i2b = lambda i: i.to_bytes((i.bit_length() + 7) // 8 or 1, "big")
+
+        # ---------- 1.  block-hash & signature -----------------------------
+        blk_mt = MerkleTree(node_get=remote_get_fn, root_hash=self.hash)
+        body_root = blk_mt.get(0); sig = blk_mt.get(1)
+        ed25519.verify_signature(public_key=self.validator_pk, message=body_root, signature=sig)
+
+        # ---------- 2.  rebuild body_root from fields ----------------------
+        f_names = (
+            "accounts_hash","block_time","delay_difficulty","delay_output","delay_proof",
+            "number","prev_block_hash","timestamp","transaction_limit",
+            "transactions_count","transactions_root_hash","transactions_total_fees",
+            "validator_pk",
+        )
+        leaves = [
+            v if isinstance(v := self.get_field(n), bytes) else _i2b(v)
+            for n in sorted(f_names)
+        ]
+        if MerkleTree.from_leaves(leaves).root_hash != body_root:
+            raise ValueError("body root mismatch")
+
+        # ---------- 3.  previous block header & VDF ------------------------
+        prev_mt = MerkleTree(node_get=remote_get_fn, root_hash=self.prev_block_hash)
+        prev_body_root, prev_sig = prev_mt.get(0), prev_mt.get(1)
+        prev_body_mt  = MerkleTree(node_get=remote_get_fn, root_hash=prev_body_root)
+        prev_blk      = Block(block_hash=self.prev_block_hash,
+                            body_tree=prev_body_mt, signature=prev_sig)
+        prev_out   = prev_blk.get_field("delay_output")
+        prev_diff  = prev_blk.get_field("delay_difficulty")
+        prev_bt    = prev_blk.get_field("block_time")
+        prev_limit = prev_blk.get_field("transaction_limit")
+        prev_cnt   = prev_blk.get_field("transactions_count")
+
+        if not vdf_verify(prev_out, self.delay_output, self.delay_proof,
+                        T=self.delay_difficulty, D=-4):
+            raise ValueError("bad VDF proof")
+
+        # ---------- 4.  replay all txs -------------------------------------
+        accs = Accounts(root_hash=prev_blk.get_field("accounts_hash"),
+                        node_get=remote_get_fn)
+        tx_mt = MerkleTree(node_get=remote_get_fn,
+                        root_hash=self.transactions_root_hash)
+        if tx_mt.leaf_count() != self.transactions_count:
+            raise ValueError("transactions_count mismatch")
+
+        dummy = Block(block_hash=b"", accounts=accs,
+                    accounts_hash=accs.root_hash,
+                    transaction_limit=prev_limit)
+        for i in range(self.transactions_count):
+            h  = tx_mt.get(i)
+            tm = MerkleTree(node_get=remote_get_fn, root_hash=h)
+            tx = Transaction(h, tree=tm, node_get=remote_get_fn)
+            dummy.apply_tx(tx)
+
+        # fee split identical to build()
+        burn = dummy.total_fees // 2
+        rew  = dummy.total_fees - burn
+        if burn:
+            dummy.accounts.set_account(
+                b"\x00"*32,
+                Account.create(burn, b"", 0)
+            )
+        if rew:
+            v_acct = dummy.accounts.get_account(self.validator_pk) or Account.create(0,b"",0)
+            dummy.accounts.set_account(
+                self.validator_pk,
+                Account.create(v_acct.balance()+rew, v_acct.data(), v_acct.nonce())
+            )
+
+        if dummy.accounts.root_hash != self.accounts_hash:
+            raise ValueError("accounts_hash mismatch")
+
+        # ---------- 5.  natural-rate rules --------------------------------
+        grow_thr   = prev_limit * NAT
+        shrink_thr = prev_cnt * NAT
+        expect_lim = prev_cnt if prev_cnt > grow_thr \
+            else max(1, int(prev_limit * NAT)) if prev_cnt < shrink_thr \
+            else prev_limit
+        if self.transaction_limit != expect_lim:
+            raise ValueError("tx-limit rule")
+
+        expect_diff = max(1, int(prev_diff / NAT)) if prev_bt <= 1 \
+                    else max(1, int(prev_diff * NAT))
+        if self.delay_difficulty != expect_diff:
+            raise ValueError("difficulty rule")
+
+        return True
+

astreum/models/merkle.py

@@ -41,11 +41,11 @@ class MerkleNode:
 class MerkleTree:
     def __init__(
         self,
-        node_get: Callable[[bytes], Optional[bytes]],
+        global_get_fn: Callable[[bytes], Optional[bytes]],
         root_hash: Optional[bytes] = None,
         height: Optional[int] = None,
     ) -> None:
-        self._node_get = node_get
+        self._global_get_fn = global_get_fn
         self.nodes: Dict[bytes, MerkleNode] = {}
         self.root_hash = root_hash
         self._height: Optional[int] = height
@@ -54,13 +54,13 @@ class MerkleTree:
     def from_leaves(
         cls,
         leaves: List[bytes],
-        node_get: Callable[[bytes], Optional[bytes]] | None = None,
+        global_get_fn: Callable[[bytes], Optional[bytes]] | None = None,
     ) -> "MerkleTree":
         if not leaves:
             raise ValueError("must supply at least one leaf")
 
-        node_get = node_get or (lambda _h: None)
-        tree = cls(node_get=node_get)
+        global_get_fn = global_get_fn or (lambda _h: None)
+        tree = cls(global_get_fn=global_get_fn)
 
         # Step 1 – create leaf nodes list[bytes]
         level_hashes: List[bytes] = []
@@ -97,7 +97,7 @@ class MerkleTree:
             return None
         node = self.nodes.get(h)
         if node is None:
-            raw = self._node_get(h)
+            raw = self._global_get_fn(h)
             if raw is None:
                 return None
             node = MerkleNode.from_bytes(raw)

astreum/models/transaction.py

@@ -27,14 +27,14 @@ class Transaction:
         tx_hash: bytes,
         *,
         tree: Optional[MerkleTree] = None,
-        get_node_fn: Optional[Callable[[bytes], Optional[bytes]]] = 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 get_node_fn:
-            self._tree.set_external_node_fetcher(get_node_fn)
+        if self._tree and global_get_fn:
+            self._tree.global_get_fn = global_get_fn
 
     @classmethod
     def create(

{astreum-0.2.24.dist-info → astreum-0.2.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.24
+Version: 0.2.26
 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.24.dist-info → astreum-0.2.26.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=mqHpsN4-aDyW9Q9emFBVIEyNvLAqRJZbqCN-4vS4Hw0,11795
-astreum/models/merkle.py,sha256=merV3rx2iRfzvglV6gNusrJf7OMbcVV854T-DUWCC64,6733
+astreum/models/block.py,sha256=-5j7uO0woVtNi0h52__e7AxpDQSVhzKUhr6Qc-2xZsE,17870
+astreum/models/merkle.py,sha256=lvWJa9nmrBL0n_2h_uNqpB_9a5s5Hn1FceRLx0IZIVQ,6778
 astreum/models/patricia.py,sha256=ohmXrcaz7Ae561tyC4u4iPOkQPkKr8N0IWJek4upFIg,13392
-astreum/models/transaction.py,sha256=yBarvRK2ybMAHHEQPZpubGO7gms4U9k093xQGNQHQ4Q,3043
-astreum-0.2.24.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.2.24.dist-info/METADATA,sha256=bcrWSsFCFwM884WECJ9THr12tMUS8MAG3VwLyaCEosg,5478
-astreum-0.2.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-astreum-0.2.24.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.2.24.dist-info/RECORD,,
+astreum/models/transaction.py,sha256=MkLL5YX18kIf9-O4LBaZ4eWjkXDAaYIrDcDehbDZoqg,3038
+astreum-0.2.26.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.2.26.dist-info/METADATA,sha256=fUG5PepefY7Cjfp5Gj5GwtbYF369bARQAcl0A4OJiQ0,5478
+astreum-0.2.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+astreum-0.2.26.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.2.26.dist-info/RECORD,,