Transaction Receipt

def has_log(self, topic: HexStr):
    """Checks is a transaction has a topic in it"""
    t = bytes.fromhex(topic.replace("0x", ""))

    return t in BloomFilter(self.logs_bloom)

def model_post_init(self, __context):
    network = self.__class__._network
    object.__setattr__(self, "_network", network)
    # overwrite the .rpc() classmethod
    object.__setattr__(self, "rpc", self._rpc)

@classmethod
def rpc(cls) -> "RPC":
    """
    This uses the default network, unless a network has been provided
    """
    from ._transport import _force_get_global_rpc

    if cls._network is None:
        return _force_get_global_rpc()
    response = _force_get_global_rpc(cls._network)
    return response

@classmethod
def get_by_hash(
    self, tx_hash: HexStr
) -> RPCResponseModel[TransactionRequest, Optional[TransactionReceiptModel]]:
    return RPCResponseModel(
        self.rpc().get_tx_receipt,
        TransactionRequest(
            tx_hash=tx_hash,
        ),
    )

@classmethod
def get_block_receipts(
    self,
    block_number: Optional[int] = None,
    block_hash: Optional[HexStr] = None,
) -> RPCResponseModel[list[HexStr], list[TransactionReceiptModel]]:
    if block_number:
        param = hex(block_number)
    elif block_hash:
        param = block_hash
    return RPCResponseModel(
        self.rpc().get_block_receipts,
        [HexStr(param)],
    )

@classmethod
def alchemy_get_block_receipts(
    self,
    block_number: Optional[int] = None,
    block_hash: Optional[HexStr] = None,
) -> RPCResponseModel[AlchemyBlockReceipt, "AlchemyReceiptsResponse"]:
    return RPCResponseModel(
        self.rpc().alchemy_get_block_receipts,
        AlchemyBlockReceipt(
            params=AlchemyParams(
                block_number=HexInteger(block_number) if block_number else None,
                block_hash=block_hash,
            )
        ),
    )