refactor: add transaction query support

src/ape/api/providers.py

@@ -22,6 +22,7 @@
 
 from ape.api.config import PluginConfig
 from ape.api.networks import LOCAL_NETWORK_NAME, NetworkAPI
+from ape.api.query import BlockTransactionQuery
 from ape.api.transactions import ReceiptAPI, TransactionAPI
 from ape.exceptions import (
     ContractLogicError,
@@ -74,6 +75,7 @@ class BlockAPI(BaseInterfaceModel):
 
     gas_data: BlockGasAPI
     consensus_data: BlockConsensusAPI
+    num_transactions: int = 0
     hash: Optional[Any] = None
     number: Optional[int] = None
     parent_hash: Optional[Any] = None
@@ -87,6 +89,11 @@ def validate_hexbytes(cls, value):
             raise ValueError(f"Hash `{value}` is not a valid Hexbyte.")
         return value
 
+    @cached_property
+    def transactions(self) -> List[TransactionAPI]:
+        query = BlockTransactionQuery(columns=["*"], block_id=self.hash)
+        return list(self.query_manager.query(query))  # type: ignore
+
 
 class ProviderAPI(BaseInterfaceModel):
     """
@@ -283,6 +290,18 @@ def get_transaction(self, txn_hash: str) -> ReceiptAPI:
             The receipt of the transaction with the given hash.
         """
 
+    @abstractmethod
+    def get_transactions_by_block(self, block_id: HexBytes) -> Iterator[TransactionAPI]:
+        """
+        Get the information about a set of transactions from a block.
+
+        Args:
+            block_id (HexBytes): The hash of a block.
+
+        Returns:
+            Iterator[:class: `~ape.api.transactions.TransactionAPI`]
+        """
+
     @abstractmethod
     def send_transaction(self, txn: TransactionAPI) -> ReceiptAPI:
         """
@@ -650,6 +669,17 @@ def get_transaction(self, txn_hash: str, required_confirmations: int = 0) -> Rec
         )
         return receipt.await_confirmations()
 
+    def get_transactions_by_block(self, block_id: BlockID) -> Iterator:
+        if isinstance(block_id, str):
+            block_id = HexStr(block_id)
+
+            if block_id.isnumeric():
+                block_id = add_0x_prefix(block_id)
+
+        block = self.web3.eth.get_block(block_id, full_transactions=True)
+        for transaction in block.get("transactions"):  # type: ignore
+            yield self.network.ecosystem.create_transaction(**transaction)  # type: ignore
+
     def get_contract_logs(
         self,
         address: Union[AddressType, List[AddressType]],

src/ape/api/query.py

@@ -6,10 +6,15 @@
 from ape.types import AddressType
 from ape.utils import BaseInterfaceModel, abstractmethod
 
-from .providers import BlockAPI
 from .transactions import TransactionAPI
 
-QueryType = Union["BlockQuery", "AccountQuery", "ContractEventQuery", "ContractMethodQuery"]
+QueryType = Union[
+    "BlockQuery",
+    "BlockTransactionQuery",
+    "AccountTransactionQuery",
+    "ContractEventQuery",
+    "ContractMethodQuery",
+]
 
 
 class _BaseQuery(BaseModel):
@@ -64,10 +69,31 @@ class BlockQuery(_BaseBlockQuery):
 
     @classmethod
     def all_fields(cls) -> List[str]:
+        from .providers import BlockAPI
+
         return list(BlockAPI.__fields__)
 
 
-class _BaseAccountQuery(_BaseQuery):
+class BlockTransactionQuery(_BaseQuery):
+    """
+    A ``QueryType`` that collects properties of ``TransactionAPI`` over a range of
+    transactions collected inside the ``BlockAPI` object represented by ``block_id``.
+    """
+
+    block_id: Any
+
+    @classmethod
+    def all_fields(cls) -> List[str]:
+        return list(TransactionAPI.__fields__)
+
+
+class AccountTransactionQuery(_BaseQuery):
+    """
+    A ``QueryType`` that collects properties of ``TransactionAPI`` over a range
+    of transactions made by ``account`` between ``start_nonce`` and ``stop_nonce``.
+    """
+
+    account: AddressType
     start_nonce: NonNegativeInt = 0
     stop_nonce: NonNegativeInt
 
@@ -81,15 +107,6 @@ def check_start_nonce_before_stop_nonce(cls, values: Dict) -> Dict:
 
         return values
 
-
-class AccountQuery(_BaseAccountQuery):
-    """
-    A ``QueryType`` that collects properties of ``TransactionAPI`` over a range
-    of transactions made by ``account`` between ``start_nonce`` and ``stop_nonce``.
-    """
-
-    account: AddressType
-
     @classmethod
     def all_fields(cls) -> List[str]:
         return list(TransactionAPI.__fields__)

src/ape/managers/query.py

@@ -3,7 +3,7 @@
 from pydantic import BaseModel
 
 from ape.api import QueryAPI, QueryType
-from ape.api.query import BlockQuery, _BaseQuery
+from ape.api.query import BlockQuery, BlockTransactionQuery, _BaseQuery
 from ape.exceptions import QueryEngineError
 from ape.plugins import clean_plugin_name
 from ape.utils import ManagerAccessMixin, cached_property, singledispatchmethod
@@ -29,6 +29,11 @@ def estimate_block_query(self, query: BlockQuery) -> Optional[int]:
         # NOTE: Very loose estimate of 100ms per block
         return (query.stop_block - query.start_block) * 100
 
+    @estimate_query.register
+    def estimate_block_transaction_query(self, query: BlockTransactionQuery) -> int:
+
+        return 100
+
     @singledispatchmethod
     def perform_query(self, query: QueryType) -> Iterator:  # type: ignore
         raise QueryEngineError(f"Cannot handle '{type(query)}'.")
@@ -42,6 +47,10 @@ def perform_block_query(self, query: BlockQuery) -> Iterator:
             range(query.start_block, query.stop_block + 1, query.step),
         )
 
+    @perform_query.register
+    def perform_block_transaction_query(self, query: BlockTransactionQuery) -> Iterator:
+        return self.provider.get_transactions_by_block(query.block_id)
+
 
 class QueryManager(ManagerAccessMixin):
     """

src/ape_ethereum/ecosystem.py

@@ -272,9 +272,9 @@ def decode_receipt(self, data: dict) -> ReceiptAPI:
             required_confirmations=data.get("required_confirmations", 0),
             txn_hash=txn_hash,
             status=status,
-            block_number=data["blockNumber"],
+            block_number=data.get("block_number") or data.get("blockNumber"),
             gas_used=data["gasUsed"],
-            gas_price=data["gasPrice"],
+            gas_price=data.get("gas_price") or data.get("gasPrice"),
             gas_limit=data.get("gas") or data.get("gasLimit"),
             logs=data.get("logs", []),
             contract_address=data.get("contractAddress"),

tests/functional/api/test_query.py

@@ -2,7 +2,7 @@
 from pydantic import ValidationError
 
 from ape import chain
-from ape.api.query import AccountQuery, BlockQuery
+from ape.api.query import AccountTransactionQuery, BlockQuery, BlockTransactionQuery
 
 
 def test_basic_query(eth_tester_provider):
@@ -15,6 +15,7 @@ def test_basic_query(eth_tester_provider):
     assert columns == [
         "gas_data",
         "consensus_data",
+        "num_transactions",
         "hash",
         "number",
         "parent_hash",
@@ -23,6 +24,32 @@ def test_basic_query(eth_tester_provider):
     ]
 
 
+def test_block_transaction_query_api():
+    query = BlockTransactionQuery(columns=["*"], block_id=0)
+    assert query.columns == [
+        "chain_id",
+        "receiver",
+        "sender",
+        "gas_limit",
+        "nonce",
+        "value",
+        "data",
+        "type",
+        "max_fee",
+        "max_priority_fee",
+        "required_confirmations",
+        "signature",
+    ]
+
+
+def test_block_transaction_query(eth_tester_provider, sender, receiver):
+    sender.transfer(receiver, 100)
+    query = chain.blocks[-1].transactions
+    assert len(query) == 1
+    assert query[0].value == 100
+    assert query[0].chain_id == 61
+
+
 def test_block_query(eth_tester_provider):
     chain.mine(3)
     with pytest.raises(ValidationError) as err:
@@ -39,8 +66,8 @@ def test_account_query(eth_tester_provider):
         account="0x0000000000000000000000000000000000000000", start_nonce=0, stop_nonce=2
     )
     with pytest.raises(ValidationError) as err:
-        AccountQuery(columns=["none"], **query_kwargs)
+        AccountTransactionQuery(columns=["none"], **query_kwargs)
     assert "Unrecognized field 'none'" in str(err.value)
     with pytest.raises(ValidationError) as err:
-        AccountQuery(columns=["nonce", "chain_id", "nonce"], **query_kwargs)
+        AccountTransactionQuery(columns=["nonce", "chain_id", "nonce"], **query_kwargs)
     assert "Duplicate fields in ['nonce', 'chain_id', 'nonce']" in str(err.value)