feat: update algopy.op.Block with fields added in AVM 11

Author: daniel-makerx

src/_algopy_testing/context_helpers/ledger_context.py

@@ -3,6 +3,8 @@
 import typing
 from collections import defaultdict
 
+import algosdk.constants
+
 from _algopy_testing.constants import MAX_BOX_SIZE
 from _algopy_testing.models.account import Account
 from _algopy_testing.primitives.uint64 import UInt64
@@ -31,7 +33,7 @@ def __init__(self) -> None:
         self._account_data = defaultdict[str, AccountContextData](get_empty_account)
         self._app_data: dict[int, ApplicationContextData] = {}
         self._asset_data: dict[int, AssetFields] = {}
-        self._blocks: dict[int, dict[str, int]] = {}
+        self._blocks: dict[int, dict[str, int | bytes | str]] = {}
         self._global_fields: GlobalFields = get_default_global_fields()
 
         self._asset_id = iter(range(1001, 2**64))
@@ -365,19 +367,49 @@ def box_exists(
         boxes = self._get_app_data(app).boxes
         return _as_box_key(key) in boxes
 
-    def set_block(
-        self, index: int, seed: algopy.UInt64 | int, timestamp: algopy.UInt64 | int
+    def set_block(  # noqa: PLR0913
+        self,
+        index: int,
+        seed: algopy.UInt64 | int,
+        timestamp: algopy.UInt64 | int,
+        bonus: algopy.UInt64 | int = 0,
+        branch: algopy.Bytes | bytes = b"",
+        fee_sink: algopy.Account | str = algosdk.constants.ZERO_ADDRESS,
+        fees_collected: algopy.UInt64 | int = 0,
+        proposer: algopy.Account | str = algosdk.constants.ZERO_ADDRESS,
+        proposer_payout: algopy.UInt64 | int = 0,
+        protocol: algopy.Bytes | bytes = b"",
+        txn_counter: algopy.UInt64 | int = 0,
     ) -> None:
         """Set block content.
 
         Args:
             index (int): The block index.
             seed (algopy.UInt64 | int): The block seed.
             timestamp (algopy.UInt64 | int): The block timestamp.
+            bonus (algopy.UInt64 | int): The block bonus.
+            branch (algopy.Bytes | bytes): The block branch.
+            fee_sink (algopy.Account | str): The block fee sink.
+            fees_collected (algopy.UInt64 | int): The fess collected.
+            proposer (algopy.Account | str): The block proposer.
+            proposer_payout (algopy.UInt64 | int): The block proposer payout.
+            protocol (algopy.Bytes | bytes): The block protocol.
+            txn_counter (algopy.UInt64 | int): The block transaction counter.
         """
-        self._blocks[index] = {"seed": int(seed), "timestamp": int(timestamp)}
-
-    def get_block_content(self, index: int, key: str) -> int:
+        self._blocks[index] = {
+            "seed": int(seed),
+            "timestamp": int(timestamp),
+            "bonus": int(bonus),
+            "branch": as_bytes(branch),
+            "fee_sink": str(fee_sink),
+            "fees_collected": int(fees_collected),
+            "proposer": str(proposer),
+            "proposer_payout": int(proposer_payout),
+            "protocol": as_bytes(protocol),
+            "txn_counter": int(txn_counter),
+        }
+
+    def get_block_content(self, index: int, key: str) -> int | bytes | str:
         """Get block content.
 
         Args:

src/_algopy_testing/op/block.py

@@ -1,28 +1,51 @@
 from __future__ import annotations
 
+import typing
 from typing import TYPE_CHECKING
 
 from _algopy_testing import op
 from _algopy_testing.context_helpers import lazy_context
-from _algopy_testing.primitives import UInt64
+from _algopy_testing.models.account import Account
+from _algopy_testing.primitives import Bytes, UInt64
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     import algopy
 
 
-class Block:
-    @staticmethod
-    def blk_seed(a: algopy.UInt64 | int, /) -> algopy.Bytes:
+_T = typing.TypeVar("_T")
+
+
+def _make_block_method(
+    field: str, conv: Callable[[typing.Any], _T]
+) -> Callable[[algopy.UInt64 | int], _T]:
+    def _read_block(index: algopy.UInt64 | int) -> _T:
         try:
-            index = int(a)
-            return op.itob(lazy_context.ledger.get_block_content(index, "seed"))
+            return conv(lazy_context.ledger.get_block_content(int(index), field))
         except KeyError as e:
-            raise KeyError(f"Block {a} not set") from e
+            raise KeyError(f"Block {index} not set") from e
 
+    return _read_block
+
+
+class Block:
     @staticmethod
-    def blk_timestamp(a: algopy.UInt64 | int, /) -> algopy.UInt64:
+    def blk_seed(index: algopy.UInt64 | int) -> Bytes:
         try:
-            index = int(a)
-            return UInt64(lazy_context.ledger.get_block_content(index, "timestamp"))
+            value = lazy_context.ledger.get_block_content(int(index), "seed")
         except KeyError as e:
-            raise KeyError(f"Block {a} not set") from e
+            raise KeyError(f"Block {index} not set") from e
+        else:
+            assert isinstance(value, int), "expected int for blk_seed"
+            return op.itob(value)
+
+    blk_timestamp = _make_block_method("timestamp", UInt64)
+    blk_bonus = _make_block_method("bonus", UInt64)
+    blk_proposer = _make_block_method("proposer", Account)
+    blk_fees_collected = _make_block_method("fees_collected", UInt64)
+    blk_txn_counter = _make_block_method("txn_counter", UInt64)
+    blk_proposer_payout = _make_block_method("proposer_payout", UInt64)
+    blk_branch = _make_block_method("branch", Bytes)
+    blk_protocol = _make_block_method("protocol", Bytes)
+    blk_fee_sink = _make_block_method("fee_sink", Account)

tests/test_op.py

@@ -938,13 +938,42 @@ def test_itxn_ops(context: AlgopyTestContext) -> None:
     assert hasattr(appl_itxn, "created_app")
 
 
-def test_blk_seed_existing_block(context: AlgopyTestContext) -> None:
+def test_blk_existing_block(context: AlgopyTestContext) -> None:
     block_index = 42
     block_seed = 123
-    context.ledger.set_block(block_index, block_seed, 1234567890)
+    sink = context.any.account()
+    fees = context.any.uint64()
+    bonus = context.any.uint64()
+    proposer = context.any.account()
+    payout = context.any.uint64()
+    protocol = context.any.bytes()
+    branch = context.any.bytes()
+    counter = context.any.uint64()
+    context.ledger.set_block(
+        block_index,
+        seed=block_seed,
+        timestamp=1234567890,
+        fee_sink=sink,
+        fees_collected=fees,
+        proposer=proposer,
+        proposer_payout=payout,
+        protocol=protocol,
+        txn_counter=counter,
+        bonus=bonus,
+        branch=branch,
+    )
     result = op.Block.blk_seed(algopy.UInt64(block_index))
     assert op.btoi(result) == block_seed
 
+    assert op.Block.blk_fee_sink(block_index) == sink
+    assert op.Block.blk_fees_collected(block_index) == fees
+    assert op.Block.blk_proposer(block_index) == proposer
+    assert op.Block.blk_proposer_payout(block_index) == payout
+    assert op.Block.blk_protocol(block_index) == protocol
+    assert op.Block.blk_txn_counter(block_index) == counter
+    assert op.Block.blk_bonus(block_index) == bonus
+    assert op.Block.blk_branch(block_index) == branch
+
 
 @pytest.mark.usefixtures("context")
 def test_blk_seed_missing_block() -> None: