def calculate_block_difficulty(self, block: Block) -> float:
""" Calculate block weight according to the ascendents of `block`, using calculate_next_weight."""
# In test mode we don't validate the block difficulty
if self.test_mode & TestMode.TEST_BLOCK_WEIGHT:
return 1.0
if block.is_genesis:
return self.min_block_weight
return self.calculate_next_weight(block.get_block_parent(),
block.timestamp)
def remove_voided_by_from_chain(self, block: Block) -> None:
""" Remove voided_by from the chain. Now, it is the best chain.
The blocks are visited from right to left (most recent to least recent).
"""
while True:
assert block.is_block
success = self.remove_voided_by(block)
if not success:
break
block = block.get_block_parent()
def update_voided_info(self, block: Block) -> None:
""" This method is called only once when a new block arrives.
The blockchain part of the DAG is a tree with the genesis block as the root.
I'll say the a block A is connected to a block B when A verifies B, i.e., B is a parent of A.
A chain is a sequence of connected blocks starting in a leaf and ending in the root, i.e., any path from a leaf
to the root is a chain. Given a chain, its head is a leaf in the tree, and its tail is the sub-chain without
the head.
The best chain is a chain that has the highest score of all chains.
The score of a block is calculated as the sum of the weights of all transactions and blocks both direcly and
indirectly verified by the block. The score of a chain is defined as the score of its head.
The side chains are the chains whose scores are smaller than the best chain's.
The head of the side chains are always voided blocks.
There are two possible states for the block chain:
(i) It has a single best chain, i.e., one chain has the highest score
(ii) It has multiple best chains, i.e., two or more chains have the same score (and this score is the highest
among the chains)
When there are multiple best chains, I'll call them best chain candidates.
The arrived block can be connected in four possible ways:
(i) To the head of a best chain
(ii) To the tail of the best chain
(iii) To the head of a side chain
(iv) To the tail of a side chain
Thus, there are eight cases to be handled when a new block arrives, which are:
(i) Single best chain, connected to the head of the best chain
(ii) Single best chain, connected to the tail of the best chain
(iii) Single best chain, connected to the head of a side chain
(iv) Single best chain, connected to the tail of a side chain
(v) Multiple best chains, connected to the head of a best chain
(vi) Multiple best chains, connected to the tail of a best chain
(vii) Multiple best chains, connected to the head of a side chain
(viii) Multiple best chains, connected to the tail of a side chain
Case (i) is trivial because the single best chain will remain as the best chain. So, just calculate the new
score and that's it.
Case (v) is also trivial. As there are multiple best chains and the new block is connected to the head of one
of them, this will be the new winner. So, the blockchain state will change to a single best chain again.
In the other cases, we must calculate the score and compare with the best score.
When there are multiple best chains, all their heads will be voided.
"""
assert block.weight > 0, 'This algorithm assumes that block\'s weight is always greater than zero'
if not block.parents:
assert block.is_genesis is True
self.update_score_and_mark_as_the_best_chain(block)
return
assert block.storage is not None
assert block.hash is not None
storage = block.storage
assert storage.indexes is not None
# Union of voided_by of parents
voided_by: Set[bytes] = self.union_voided_by_from_parents(block)
# Update accumulated weight of the transactions voiding us.
assert block.hash not in voided_by
for h in voided_by:
tx = storage.get_transaction(h)
tx_meta = tx.get_metadata()
tx_meta.accumulated_weight = sum_weights(
tx_meta.accumulated_weight, block.weight)
storage.save_transaction(tx, only_metadata=True)
# Check conflicts of the transactions voiding us.
for h in voided_by:
tx = storage.get_transaction(h)
if not tx.is_block:
assert isinstance(tx, Transaction)
self.consensus.transaction_algorithm.check_conflicts(tx)
parent = block.get_block_parent()
parent_meta = parent.get_metadata()
assert block.hash in parent_meta.children
# This method is called after the metadata of the parent is updated.
# So, if the parent has only one child, it must be the current block.
is_connected_to_the_head = bool(len(parent_meta.children) == 1)
is_connected_to_the_best_chain = bool(not parent_meta.voided_by)
if is_connected_to_the_head and is_connected_to_the_best_chain:
# Case (i): Single best chain, connected to the head of the best chain
self.update_score_and_mark_as_the_best_chain_if_possible(block)
# As `update_score_and_mark_as_the_best_chain_if_possible` may affect `voided_by`,
# we need to check that block is not voided.
meta = block.get_metadata()
if not meta.voided_by:
storage.indexes.height.add_new(meta.height, block.hash,
block.timestamp)
storage.update_best_block_tips_cache([block.hash])
# The following assert must be true, but it is commented out for performance reasons.
if settings.SLOW_ASSERTS:
assert len(storage.get_best_block_tips(skip_cache=True)) == 1
else:
# Resolve all other cases, but (i).
log = self.log.new(block=block.hash_hex)
log.debug(
'this block is not the head of the bestchain',
is_connected_to_the_head=is_connected_to_the_head,
is_connected_to_the_best_chain=is_connected_to_the_best_chain)
# First, void this block.
self.mark_as_voided(block, skip_remove_first_block_markers=True)
# Get the score of the best chains.
# We need to void this block first, because otherwise it would always be one of the heads.
heads = [
cast(Block, storage.get_transaction(h))
for h in storage.get_best_block_tips()
]
best_score = None
for head in heads:
head_meta = head.get_metadata(force_reload=True)
if best_score is None:
best_score = head_meta.score
else:
# All heads must have the same score.
assert abs(best_score - head_meta.score) < 1e-10
assert isinstance(best_score, (int, float))
# Calculate the score.
# We cannot calculate score before getting the heads.
score = self.calculate_score(block)
# Finally, check who the winner is.
if score <= best_score - settings.WEIGHT_TOL:
# Just update voided_by from parents.
self.update_voided_by_from_parents(block)
else:
# Either eveyone has the same score or there is a winner.
valid_heads = []
for head in heads:
meta = head.get_metadata()
if not meta.voided_by:
valid_heads.append(head)
# We must have at most one valid head.
# Either we have a single best chain or all chains have already been voided.
assert len(
valid_heads
) <= 1, 'We must never have more than one valid head'
# Add voided_by to all heads.
self.add_voided_by_to_multiple_chains(block, heads)
if score >= best_score + settings.WEIGHT_TOL:
# We have a new winner candidate.
self.update_score_and_mark_as_the_best_chain_if_possible(
block)
# As `update_score_and_mark_as_the_best_chain_if_possible` may affect `voided_by`,
# we need to check that block is not voided.
meta = block.get_metadata()
if not meta.voided_by:
self.log.debug('index new winner block',
height=meta.height,
block=block.hash_hex)
# We update the height cache index with the new winner chain
storage.indexes.height.update_new_chain(
meta.height, block)
storage.update_best_block_tips_cache([block.hash])
else:
storage.update_best_block_tips_cache(
[not_none(blk.hash) for blk in heads])