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

astreum/models/block.py

@@ -4,8 +4,8 @@ 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._consensus.account import Account
+from astreum._consensus.accounts import Accounts
 from astreum.models.patricia import PatriciaTrie
 from astreum.models.transaction import Transaction
 from ..crypto import ed25519
@@ -32,7 +32,7 @@ class Block:
         accounts: Optional[Accounts] = None,
         transaction_limit: Optional[int] = None,
         transactions_total_fees: Optional[int] = None,
-        transactions_root_hash: Optional[bytes] = None,
+        transactions_hash: Optional[bytes] = None,
         transactions_count: Optional[int] = None,
         delay_difficulty: Optional[int] = None,
         delay_output: Optional[bytes] = None,
@@ -49,14 +49,14 @@ class Block:
         self.accounts = accounts
         self.transaction_limit = transaction_limit
         self.transactions_total_fees = transactions_total_fees
-        self.transactions_root_hash = transactions_root_hash
+        self.transactions_hash = transactions_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
+        self.delay_proof = delay_proof
+        self.validator_pk = validator_pk
+        self.body_tree = body_tree
+        self.signature = signature
 
     @property
     def hash(self) -> bytes:
@@ -68,11 +68,20 @@ class Block:
             raise ValueError("Body tree not available for this block instance.")
         return self._body_tree.root_hash
 
-    def get_signature(self) -> bytes:
-        """Return the block's signature leaf."""
-        if self._signature is None:
-            raise ValueError("Signature not available for this block instance.")
-        return self._signature
+    def get_signature(self) -> bytes:
+        """Return the block's signature leaf."""
+        if self._signature is None:
+            raise ValueError("Signature not available for this block instance.")
+        return self._signature
+
+    # Backwards/forwards alias for clarity with external specs
+    @property
+    def validator_public_key(self) -> Optional[bytes]:
+        return self.validator_pk
+
+    @validator_public_key.setter
+    def validator_public_key(self, value: Optional[bytes]) -> None:
+        self.validator_pk = value
 
     def get_field(self, name: str) -> Union[int, bytes]:
         """Query a single body field by name, returning an int or bytes."""
@@ -94,9 +103,9 @@ class Block:
         stake_root = stake_trie.root_hash
 
         # 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)
+        validator_acct = Account.create(balance=0, data=b"", counter=0)
+        treasury_acct  = Account.create(balance=1, data=stake_root, counter=0)
+        burn_acct = Account.create(balance=0, data=b"", counter=0)
 
         # 3. global Accounts structure
         accts = Accounts()
@@ -116,7 +125,7 @@ class Block:
             accounts                = accts,
             transactions_total_fees = 0,
             transaction_limit       = 1,
-            transactions_root_hash  = b"\x00" * 32,
+            transactions_hash       = b"\x00" * 32,
             transactions_count      = 0,
             delay_difficulty        = 1,
             delay_output            = b"",
@@ -181,7 +190,7 @@ class Block:
 
         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()))
+            blk.accounts.set_account(addr, Account.create(acc.balance + amt, acc.data, acc.counter))
 
         if burn_amt:
             _credit(BURN, burn_amt)
@@ -210,7 +219,7 @@ class Block:
         # ------------------ 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_hash = MerkleTree.from_leaves(blk.tx_hashes).root_hash
         blk.transactions_total_fees = blk.total_fees
 
         # ------------------ build full body root ----------------------------
@@ -225,7 +234,7 @@ class Block:
             "timestamp":               blk.timestamp,
             "transaction_limit":       blk.transaction_limit,
             "transactions_count":      blk.transactions_count,
-            "transactions_root_hash":  blk.transactions_root_hash,
+            "transactions_hash":       blk.transactions_hash,
             "transactions_total_fees": blk.transactions_total_fees,
             "validator_pk":            blk.validator_pk,
         }
@@ -271,17 +280,17 @@ class Block:
 
         sender_acct = self.accounts.get_account(sender_pk)
         if (sender_acct is None
-            or sender_acct.nonce() != nonce
-            or sender_acct.balance() < amount + fee):
+            or sender_acct.counter != 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,
+                balance=sender_acct.balance - amount - fee,
+                data=sender_acct.data,
+                counter=sender_acct.counter + 1,
             )
         )
 
@@ -289,14 +298,14 @@ class Block:
         if recip_pk == TREASURY:
             treasury = self.accounts.get_account(TREASURY)
 
-            trie = PatriciaTrie(node_get=None, root_hash=treasury.data())
+            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
+                new_treas_bal = treasury.balance + amount
             else:
                 # stake **withdrawal**
                 if current_stake == 0:
@@ -306,13 +315,13 @@ class Block:
                 self.accounts.set_account(
                     sender_pk,
                     Account.create(
-                        balance=sender_after.balance() + current_stake,
-                        data=sender_after.data(),
-                        nonce=sender_after.nonce(),
+                        balance=sender_after.balance + current_stake,
+                        data=sender_after.data,
+                        counter=sender_after.counter,
                     )
                 )
                 trie.delete(sender_pk)
-                new_treas_bal = treasury.balance()  # treasury balance unchanged
+                new_treas_bal = treasury.balance  # treasury balance unchanged
 
             # write back treasury with new trie root
             self.accounts.set_account(
@@ -320,7 +329,7 @@ class Block:
                 Account.create(
                     balance=new_treas_bal,
                     data=trie.root_hash,
-                    nonce=treasury.nonce(),
+                    counter=treasury.counter,
                 )
             )
 
@@ -329,9 +338,9 @@ class Block:
             self.accounts.set_account(
                 recip_pk,
                 Account.create(
-                    balance=recip_acct.balance() + amount,
-                    data=recip_acct.data(),
-                    nonce=recip_acct.nonce(),
+                    balance=recip_acct.balance + amount,
+                    data=recip_acct.data,
+                    counter=recip_acct.counter,
                 )
             )
 
@@ -353,7 +362,7 @@ class Block:
         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",
+            "transactions_count","transactions_hash","transactions_total_fees",
             "validator_pk",
         )
         leaves = [
@@ -382,8 +391,8 @@ class Block:
         # ---------- 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)
+        tx_mt = MerkleTree(node_get=remote_get_fn,
+                        root_hash=self.transactions_hash)
         if tx_mt.leaf_count() != self.transactions_count:
             raise ValueError("transactions_count mismatch")
 
@@ -408,7 +417,7 @@ class Block:
             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())
+                Account.create(v_acct.balance+rew, v_acct.data, v_acct.counter)
             )
 
         if dummy.accounts.root_hash != self.accounts_hash: