Implement get_transaction_receipt function as part of ChainDB (#1705)

* Implement get_transaction_receipt function as part of ChainDB

* Add tests for get_transaction_receipt function of ChainDB

Author: Bhargavasomu

eth/db/chain.py

@@ -28,6 +28,7 @@
 )
 from eth.exceptions import (
     HeaderNotFound,
+    ReceiptNotFound,
     TransactionNotFound,
 )
 from eth.db.header import BaseHeaderDB, HeaderDB
@@ -395,6 +396,27 @@ def get_transaction_index(self, transaction_hash: Hash32) -> Tuple[BlockNumber,
         transaction_key = rlp.decode(encoded_key, sedes=TransactionKey)
         return (transaction_key.block_number, transaction_key.index)
 
+    def get_receipt_by_index(self,
+                             block_number: BlockNumber,
+                             receipt_index: int) -> Receipt:
+        """
+        Returns the Receipt of the transaction at specified index
+        for the block header obtained by the specified block number
+        """
+        try:
+            block_header = self.get_canonical_block_header_by_number(block_number)
+        except HeaderNotFound:
+            raise ReceiptNotFound("Block {} is not in the canonical chain".format(block_number))
+
+        receipt_db = HexaryTrie(db=self.db, root_hash=block_header.receipt_root)
+        receipt_key = rlp.encode(receipt_index)
+        if receipt_key in receipt_db:
+            receipt_data = receipt_db[receipt_key]
+            return rlp.decode(receipt_data, sedes=Receipt)
+        else:
+            raise ReceiptNotFound(
+                "Receipt with index {} not found in block".format(receipt_index))
+
     @staticmethod
     def _get_block_transaction_data(db: BaseDB, transaction_root: Hash32) -> Iterable[Hash32]:
         """

eth/exceptions.py

@@ -39,6 +39,13 @@ class TransactionNotFound(PyEVMError):
     pass
 
 
+class ReceiptNotFound(PyEVMError):
+    """
+    Raised when the Receipt with the given receipt index does not exist.
+    """
+    pass
+
+
 class ParentNotFound(HeaderNotFound):
     """
     Raised when the parent of a given block does not exist.

tests/database/test_eth1_chaindb.py

@@ -12,27 +12,38 @@
 from eth.constants import (
     BLANK_ROOT_HASH,
 )
+from eth.chains.base import (
+    MiningChain,
+)
 from eth.db.chain import (
     ChainDB,
 )
 from eth.db.schema import SchemaV1
 from eth.exceptions import (
     HeaderNotFound,
     ParentNotFound,
+    ReceiptNotFound,
 )
 from eth.rlp.headers import (
     BlockHeader,
 )
 from eth.tools.rlp import (
     assert_headers_eq,
 )
+from eth._utils.address import (
+    force_bytes_to_address,
+)
 from eth.vm.forks.frontier.blocks import (
     FrontierBlock,
 )
 from eth.vm.forks.homestead.blocks import (
     HomesteadBlock,
 )
 
+from tests.core.helpers import (
+    new_transaction,
+)
+
 
 A_ADDRESS = b"\xaa" * 20
 B_ADDRESS = b"\xbb" * 20
@@ -64,6 +75,14 @@ def block(request, header):
     return request.param(header)
 
 
+@pytest.fixture
+def chain(chain_without_block_validation):
+    if not isinstance(chain_without_block_validation, MiningChain):
+        pytest.skip("these tests require a mining chain implementation")
+    else:
+        return chain_without_block_validation
+
+
 def test_chaindb_add_block_number_to_hash_lookup(chaindb, block):
     block_number_to_hash_key = SchemaV1.make_block_number_to_hash_lookup_key(block.number)
     assert not chaindb.exists(block_number_to_hash_key)
@@ -129,3 +148,50 @@ def test_chaindb_get_canonical_block_hash(chaindb, block):
     chaindb.persist_block(block)
     block_hash = chaindb.get_canonical_block_hash(block.number)
     assert block_hash == block.hash
+
+
+def test_chaindb_get_receipt_by_index(
+        chain,
+        funded_address,
+        funded_address_private_key):
+    NUMBER_BLOCKS_IN_CHAIN = 5
+    TRANSACTIONS_IN_BLOCK = 10
+    REQUIRED_BLOCK_NUMBER = 2
+    REQUIRED_RECEIPT_INDEX = 3
+
+    for block_number in range(NUMBER_BLOCKS_IN_CHAIN):
+        for tx_index in range(TRANSACTIONS_IN_BLOCK):
+            tx = new_transaction(
+                chain.get_vm(),
+                from_=funded_address,
+                to=force_bytes_to_address(b'\x10\x10'),
+                private_key=funded_address_private_key,
+            )
+            new_block, tx_receipt, computation = chain.apply_transaction(tx)
+            assert computation.is_success
+
+            if (block_number + 1) == REQUIRED_BLOCK_NUMBER and tx_index == REQUIRED_RECEIPT_INDEX:
+                actual_receipt = tx_receipt
+
+        chain.mine_block()
+
+    # Check that the receipt retrieved is indeed the actual one
+    chaindb_retrieved_receipt = chain.chaindb.get_receipt_by_index(
+        REQUIRED_BLOCK_NUMBER,
+        REQUIRED_RECEIPT_INDEX,
+    )
+    assert chaindb_retrieved_receipt == actual_receipt
+
+    # Raise error if block number is not found
+    with pytest.raises(ReceiptNotFound):
+        chain.chaindb.get_receipt_by_index(
+            NUMBER_BLOCKS_IN_CHAIN + 1,
+            REQUIRED_RECEIPT_INDEX,
+        )
+
+    # Raise error if receipt index is out of range
+    with pytest.raises(ReceiptNotFound):
+        chain.chaindb.get_receipt_by_index(
+            NUMBER_BLOCKS_IN_CHAIN,
+            TRANSACTIONS_IN_BLOCK + 1,
+        )