def _get_score(db: BaseDB, block_hash: Hash32) -> int:
try:
encoded_score = db[SchemaV1.make_block_hash_to_score_lookup_key(block_hash)]
except KeyError:
raise HeaderNotFound("No header with hash {0} found".format(
encode_hex(block_hash)))
return rlp.decode(encoded_score, sedes=rlp.sedes.big_endian_int)
async def _get_block_header_by_hash(self, block_hash: Hash32,
peer: LESPeer) -> BlockHeader:
"""
A single attempt to get the block header from the given peer.
:raise BadLESResponse: if the peer replies with a header that has a different hash
"""
self.logger.debug("Fetching header %s from %s", encode_hex(block_hash),
peer)
max_headers = 1
# TODO: Figure out why mypy thinks the first parameter to `get_block_headers`
# should be of type `int`
headers = await peer.chain_api.get_block_headers(
block_hash,
max_headers,
skip=0,
reverse=False,
)
if not headers:
raise HeaderNotFound(
f"Peer {peer} has no block with hash {block_hash}")
header = headers[0]
if header.hash != block_hash:
raise BadLESResponse(
f"Received header hash ({header.hex_hash}) does not "
f"match what we requested ({encode_hex(block_hash)})")
return header
async def _get_block_header_by_hash(self, block_hash: Hash32,
peer: LESPeer) -> BlockHeader:
"""
A single attempt to get the block header from the given peer.
:raise BadLESResponse: if the peer replies with a header that has a different hash
"""
self.logger.debug("Fetching header %s from %s", encode_hex(block_hash),
peer)
max_headers = 1
headers = await peer.requests.get_block_headers(
block_hash,
max_headers,
skip=0,
reverse=False,
)
if not headers:
raise HeaderNotFound("Peer {} has no block with hash {}".format(
peer, block_hash))
header = headers[0]
if header.hash != block_hash:
raise BadLESResponse(
"Received header hash (%s) does not match what we requested (%s)",
header.hex_hash, encode_hex(block_hash))
return header
def _get_canonical_block_hash(db: BaseDB, block_number: BlockNumber) -> Hash32:
validate_block_number(block_number)
number_to_hash_key = SchemaV1.make_block_number_to_hash_lookup_key(block_number)
try:
encoded_key = db[number_to_hash_key]
except KeyError:
raise HeaderNotFound(
"No canonical header for block number #{0}".format(block_number)
)
else:
return rlp.decode(encoded_key, sedes=rlp.sedes.binary)
def _get_block_header_by_hash(db: DatabaseAPI, block_hash: Hash32) -> BlockHeaderAPI:
"""
Returns the requested block header as specified by block hash.
Raises BlockNotFound if it is not present in the db.
"""
validate_word(block_hash, title="Block Hash")
try:
header_rlp = db[block_hash]
except KeyError:
raise HeaderNotFound(f"No header with hash {encode_hex(block_hash)} found")
return _decode_block_header(header_rlp)
def get_block_uncles(self, uncles_hash: Hash32) -> Tuple[BlockHeaderAPI, ...]:
validate_word(uncles_hash, title="Uncles Hash")
if uncles_hash == EMPTY_UNCLE_HASH:
return ()
try:
encoded_uncles = self.db[uncles_hash]
except KeyError as exc:
raise HeaderNotFound(
f"No uncles found for hash {uncles_hash!r}"
) from exc
else:
return tuple(rlp.decode(encoded_uncles, sedes=rlp.sedes.CountableList(BlockHeader)))
def get_block_header_by_hash(self, block_hash: Hash32) -> BlockHeader:
"""
Returns the requested block header as specified by block hash.
Raises BlockNotFound if it is not present in the db.
"""
validate_word(block_hash, title="Block Hash")
try:
header_rlp = self.db[block_hash]
except KeyError:
raise HeaderNotFound("No header with hash {0} found".format(
encode_hex(block_hash)))
return _decode_block_header(header_rlp)
def get_block_uncles(self, uncles_hash: Hash32) -> List[BlockHeader]:
"""
Returns an iterable of uncle headers specified by the given uncles_hash
"""
validate_word(uncles_hash, title="Uncles Hash")
if uncles_hash == EMPTY_UNCLE_HASH:
return []
try:
encoded_uncles = self.db[uncles_hash]
except KeyError:
raise HeaderNotFound(
"No uncles found for hash {0}".format(uncles_hash))
else:
return rlp.decode(encoded_uncles,
sedes=rlp.sedes.CountableList(BlockHeader))
def get_canonical_block_hash(self, block_number: BlockNumber) -> Hash32:
"""
Returns the block hash for the canonical block at the given number.
Raises BlockNotFound if there's no block header with the given number in the
canonical chain.
"""
validate_block_number(block_number, title="Block Number")
number_to_hash_key = SchemaV1.make_block_number_to_hash_lookup_key(
block_number)
try:
encoded_key = self.db[number_to_hash_key]
except KeyError:
raise HeaderNotFound(
"No canonical header for block number #{0}".format(
block_number))
else:
return rlp.decode(encoded_key, sedes=rlp.sedes.binary)
async def _get_block_header_by_hash(self, block_hash: Hash32,
peer: LESPeer) -> BlockHeader:
"""
A single attempt to get the block header from the given peer.
:raise BadLESResponse: if the peer replies with a header that has a different hash
"""
self.logger.debug("Fetching header %s from %s", encode_hex(block_hash),
peer)
request_id = gen_request_id()
max_headers = 1
peer.sub_proto.send_get_block_headers(block_hash, max_headers, 0,
False, request_id)
reply = await self._wait_for_reply(request_id)
if not reply['headers']:
raise HeaderNotFound("Peer {} has no block with hash {}".format(
peer, block_hash))
header = reply['headers'][0]
if header.hash != block_hash:
raise BadLESResponse(
"Received header hash (%s) does not match what we requested (%s)",
header.hex_hash, encode_hex(block_hash))
return header
