def find_fork_point_in_chain( sub_blocks: BlockchainInterface, sub_block_1: Union[SubBlockRecord, HeaderBlock], sub_block_2: Union[SubBlockRecord, HeaderBlock], ) -> int: """Tries to find height where new chain (sub_block_2) diverged from sub_block_1 (assuming prev blocks are all included in chain) Returns -1 if chains have no common ancestor * assumes forkpoint is loaded in sub_blocks """ while sub_block_2.height > 0 or sub_block_1.height > 0: if sub_block_2.height > sub_block_1.height: sub_block_2 = sub_blocks.sub_block_record(sub_block_2.prev_hash) elif sub_block_1.height > sub_block_2.height: sub_block_1 = sub_blocks.sub_block_record(sub_block_1.prev_hash) else: if sub_block_2.header_hash == sub_block_1.header_hash: return sub_block_2.height sub_block_2 = sub_blocks.sub_block_record(sub_block_2.prev_hash) sub_block_1 = sub_blocks.sub_block_record(sub_block_1.prev_hash) if sub_block_2 != sub_block_1: # All blocks are different return -1 # First block is the same return 0
def get_block_challenge( constants: ConsensusConstants, header_block: Union[UnfinishedHeaderBlock, UnfinishedBlock, HeaderBlock, FullBlock], sub_blocks: BlockchainInterface, genesis_block: bool, overflow: bool, skip_overflow_last_ss_validation: bool, ): if len(header_block.finished_sub_slots) > 0: if overflow: # New sub-slot with overflow block if skip_overflow_last_ss_validation: # In this case, we are missing the final sub-slot bundle (it's not finished yet) challenge: bytes32 = header_block.finished_sub_slots[ -1].challenge_chain.get_hash() else: challenge = header_block.finished_sub_slots[ -1].challenge_chain.challenge_chain_end_of_slot_vdf.challenge else: # No overflow, new slot with a new challenge challenge = header_block.finished_sub_slots[ -1].challenge_chain.get_hash() else: if genesis_block: challenge = constants.GENESIS_CHALLENGE else: if overflow: if skip_overflow_last_ss_validation: # Overflow infusion without the new slot, so get the last challenge challenges_to_look_for = 1 else: # Overflow infusion, so get the second to last challenge challenges_to_look_for = 2 else: challenges_to_look_for = 1 reversed_challenge_hashes: List[bytes32] = [] curr: SubBlockRecord = sub_blocks.sub_block_record( header_block.prev_header_hash) while len(reversed_challenge_hashes) < challenges_to_look_for: if curr.first_in_sub_slot: assert curr.finished_challenge_slot_hashes is not None reversed_challenge_hashes += reversed( curr.finished_challenge_slot_hashes) if curr.height == 0: assert curr.finished_challenge_slot_hashes is not None assert len(curr.finished_challenge_slot_hashes) > 0 break curr = sub_blocks.sub_block_record(curr.prev_hash) challenge = reversed_challenge_hashes[challenges_to_look_for - 1] return challenge
def get_sub_slot_iters_and_difficulty( constants: ConsensusConstants, header_block: Union[UnfinishedHeaderBlock, UnfinishedBlock, HeaderBlock, FullBlock], prev_sb: Optional[SubBlockRecord], sub_blocks: BlockchainInterface, ) -> Tuple[uint64, uint64]: """ Retrieves the current sub_slot iters and difficulty of the sub_block header_block. Note, this is the current difficulty, not the next one. Args: constants: consensus constants being used for this chain header_block: the current sub-block prev_sb: the previous sub-block before header_block sub_blocks: dictionary from header hash to SBR of all included SBR """ # genesis if prev_sb is None: return constants.SUB_SLOT_ITERS_STARTING, constants.DIFFICULTY_STARTING if prev_sb.height != 0: prev_difficulty: uint64 = uint64( prev_sb.weight - sub_blocks.sub_block_record(prev_sb.prev_hash).weight) else: # prev block is genesis prev_difficulty = uint64(prev_sb.weight) sp_total_iters = prev_sb.sp_total_iters(constants) difficulty: uint64 = get_next_difficulty( constants, sub_blocks, prev_sb.prev_hash, prev_sb.height, prev_difficulty, prev_sb.deficit, len(header_block.finished_sub_slots) > 0, sp_total_iters, ) sub_slot_iters: uint64 = get_next_sub_slot_iters( constants, sub_blocks, prev_sb.prev_hash, prev_sb.height, prev_sb.sub_slot_iters, prev_sb.deficit, len(header_block.finished_sub_slots) > 0, sp_total_iters, ) return sub_slot_iters, difficulty
def get_prev_block( curr: SubBlockRecord, sub_blocks: BlockchainInterface, total_iters_sp: uint128, ) -> Tuple[bool, SubBlockRecord]: prev_block = curr while not curr.is_block: curr = sub_blocks.sub_block_record(curr.prev_hash) if total_iters_sp > curr.total_iters: prev_block = curr is_block = True else: is_block = False return is_block, prev_block
def make_sub_epoch_summary( constants: ConsensusConstants, sub_blocks: BlockchainInterface, blocks_included_height: uint32, prev_prev_sub_block: SubBlockRecord, new_difficulty: Optional[uint64], new_sub_slot_iters: Optional[uint64], ) -> SubEpochSummary: """ Creates a sub-epoch-summary object, assuming that the first sub-block in the new sub-epoch is at height "blocks_included_height". Prev_prev_sb is the second to last sub block in the previous sub-epoch. On a new epoch, new_difficulty and new_sub_slot_iters are also added. Args: constants: consensus constants being used for this chain sub_blocks: dictionary from header hash to SBR of all included SBR blocks_included_height: sub_block height in which the SES will be included prev_prev_sub_block: second to last sub-block in epoch new_difficulty: difficulty in new epoch new_sub_slot_iters: sub slot iters in new epoch """ assert prev_prev_sub_block.height == blocks_included_height - 2 # If first sub_epoch. Adds MAX_SUB_SLOT_SUB_BLOCKS because blocks_included_height might be behind if (blocks_included_height + constants.MAX_SUB_SLOT_SUB_BLOCKS) // constants.SUB_EPOCH_SUB_BLOCKS == 1: return SubEpochSummary( constants.GENESIS_CHALLENGE, constants.GENESIS_CHALLENGE, uint8(0), None, None, ) curr: SubBlockRecord = prev_prev_sub_block while curr.sub_epoch_summary_included is None: curr = sub_blocks.sub_block_record(curr.prev_hash) assert curr is not None assert curr.finished_reward_slot_hashes is not None prev_ses = curr.sub_epoch_summary_included.get_hash() return SubEpochSummary( prev_ses, curr.finished_reward_slot_hashes[-1], uint8(curr.height % constants.SUB_EPOCH_SUB_BLOCKS), new_difficulty, new_sub_slot_iters, )
def _get_blocks_at_height( sub_blocks: BlockchainInterface, prev_sb: SubBlockRecord, target_height: uint32, max_num_sub_blocks: uint32 = uint32(1), ) -> List[SubBlockRecord]: """ Return a consecutive list of SubBlockRecords starting at target_height, returning a maximum of max_num_sub_blocks. Assumes all sub-block records are present. Does a slot linear search, if the sub-blocks are not in the path of the peak. Args: sub_blocks: dict from header hash to SubBlockRecord. prev_sb: prev_sb (to start backwards search). target_height: target sub-block to start max_num_sub_blocks: max number of sub-blocks to fetch (although less might be fetched) """ if sub_blocks.contains_height(prev_sb.height): header_hash = sub_blocks.height_to_hash(prev_sb.height) if header_hash == prev_sb.header_hash: # Efficient fetching, since we are fetching ancestor blocks within the heaviest chain block_list: List[SubBlockRecord] = [] for h in range(target_height, target_height + max_num_sub_blocks): assert sub_blocks.contains_height(uint32(h)) block_list.append( sub_blocks.height_to_sub_block_record(uint32(h))) return block_list # slow fetching, goes back one by one curr_b: SubBlockRecord = prev_sb target_blocks = [] while curr_b.height >= target_height: if curr_b.height < target_height + max_num_sub_blocks: target_blocks.append(curr_b) if curr_b.height == 0: break curr_b = sub_blocks.sub_block_record(curr_b.prev_hash) return list(reversed(target_blocks))
async def validate_block_body( constants: ConsensusConstants, sub_blocks: BlockchainInterface, block_store: BlockStore, coin_store: CoinStore, peak: Optional[SubBlockRecord], block: Union[FullBlock, UnfinishedBlock], height: uint32, cached_cost_result: Optional[CostResult] = None, fork_point_with_peak: Optional[uint32] = None, ) -> Optional[Err]: """ This assumes the header block has been completely validated. Validates the transactions and body of the block. Returns None if everything validates correctly, or an Err if something does not validate. """ if isinstance(block, FullBlock): assert height == block.height prev_transaction_block_height: uint32 = uint32(0) # 1. For non block sub-blocks, foliage block, transaction filter, transactions info, and generator must be empty # If it is a sub block but not a block, there is no body to validate. Check that all fields are None if block.foliage_sub_block.foliage_block_hash is None: if (block.foliage_block is not None or block.transactions_info is not None or block.transactions_generator is not None): return Err.NOT_BLOCK_BUT_HAS_DATA return None # This means the sub-block is valid # 2. For blocks, foliage block, transaction filter, transactions info must not be empty if block.foliage_block is None or block.foliage_block.filter_hash is None or block.transactions_info is None: return Err.IS_BLOCK_BUT_NO_DATA # keeps track of the reward coins that need to be incorporated expected_reward_coins: Set[Coin] = set() # 3. The transaction info hash in the Foliage block must match the transaction info if block.foliage_block.transactions_info_hash != std_hash( block.transactions_info): return Err.INVALID_TRANSACTIONS_INFO_HASH # 4. The foliage block hash in the foliage sub block must match the foliage block if block.foliage_sub_block.foliage_block_hash != std_hash( block.foliage_block): return Err.INVALID_FOLIAGE_BLOCK_HASH # 5. The prev generators root must be valid # TODO(straya): implement prev generators # 6. The generator root must be the tree-hash of the generator (or zeroes if no generator) if block.transactions_generator is not None: if block.transactions_generator.get_tree_hash( ) != block.transactions_info.generator_root: return Err.INVALID_TRANSACTIONS_GENERATOR_ROOT else: if block.transactions_info.generator_root != bytes([0] * 32): return Err.INVALID_TRANSACTIONS_GENERATOR_ROOT # 7. The reward claims must be valid for the previous sub-blocks, and current block fees if height > 0: # Add reward claims for all sub-blocks from the prev prev block, until the prev block (including the latter) prev_block = sub_blocks.sub_block_record( block.foliage_block.prev_block_hash) prev_transaction_block_height = prev_block.height assert prev_block.fees is not None pool_coin = create_pool_coin( prev_block.height, prev_block.pool_puzzle_hash, calculate_pool_reward(prev_block.height), ) farmer_coin = create_farmer_coin( prev_block.height, prev_block.farmer_puzzle_hash, uint64( calculate_base_farmer_reward(prev_block.height) + prev_block.fees), ) # Adds the previous block expected_reward_coins.add(pool_coin) expected_reward_coins.add(farmer_coin) # For the second block in the chain, don't go back further if prev_block.height > 0: curr_sb = sub_blocks.sub_block_record(prev_block.prev_hash) while not curr_sb.is_block: expected_reward_coins.add( create_pool_coin( curr_sb.height, curr_sb.pool_puzzle_hash, calculate_pool_reward(curr_sb.height), )) expected_reward_coins.add( create_farmer_coin( curr_sb.height, curr_sb.farmer_puzzle_hash, calculate_base_farmer_reward(curr_sb.height), )) curr_sb = sub_blocks.sub_block_record(curr_sb.prev_hash) if set(block.transactions_info.reward_claims_incorporated ) != expected_reward_coins: return Err.INVALID_REWARD_COINS removals: List[bytes32] = [] coinbase_additions: List[Coin] = list(expected_reward_coins) additions: List[Coin] = [] announcements: List[Announcement] = [] npc_list: List[NPC] = [] removals_puzzle_dic: Dict[bytes32, bytes32] = {} cost: uint64 = uint64(0) if height <= constants.INITIAL_FREEZE_PERIOD and block.transactions_generator is not None: return Err.INITIAL_TRANSACTION_FREEZE if block.transactions_generator is not None: # Get List of names removed, puzzles hashes for removed coins and conditions crated if cached_cost_result is not None: result: CostResult = cached_cost_result else: result = calculate_cost_of_program( block.transactions_generator, constants.CLVM_COST_RATIO_CONSTANT) cost = result.cost npc_list = result.npc_list # 8. Check that cost <= MAX_BLOCK_COST_CLVM if cost > constants.MAX_BLOCK_COST_CLVM: return Err.BLOCK_COST_EXCEEDS_MAX if result.error is not None: return Err(result.error) for npc in npc_list: removals.append(npc.coin_name) removals_puzzle_dic[npc.coin_name] = npc.puzzle_hash additions = additions_for_npc(npc_list) announcements = announcements_for_npc(npc_list) # 9. Check that the correct cost is in the transactions info if block.transactions_info.cost != cost: return Err.INVALID_BLOCK_COST additions_dic: Dict[bytes32, Coin] = {} # 10. Check additions for max coin amount # Be careful to check for 64 bit overflows in other languages. This is the max 64 bit unsigned integer for coin in additions + coinbase_additions: additions_dic[coin.name()] = coin if coin.amount >= constants.MAX_COIN_AMOUNT: return Err.COIN_AMOUNT_EXCEEDS_MAXIMUM # 11. Validate addition and removal roots root_error = validate_block_merkle_roots( block.foliage_block.additions_root, block.foliage_block.removals_root, additions + coinbase_additions, removals, ) if root_error: return root_error # 12. The additions and removals must result in the correct filter byte_array_tx: List[bytes32] = [] for coin in additions + coinbase_additions: byte_array_tx.append(bytearray(coin.puzzle_hash)) for coin_name in removals: byte_array_tx.append(bytearray(coin_name)) bip158: PyBIP158 = PyBIP158(byte_array_tx) encoded_filter = bytes(bip158.GetEncoded()) filter_hash = std_hash(encoded_filter) if filter_hash != block.foliage_block.filter_hash: return Err.INVALID_TRANSACTIONS_FILTER_HASH # 13. Check for duplicate outputs in additions addition_counter = collections.Counter( _.name() for _ in additions + coinbase_additions) for k, v in addition_counter.items(): if v > 1: return Err.DUPLICATE_OUTPUT # 14. Check for duplicate spends inside block removal_counter = collections.Counter(removals) for k, v in removal_counter.items(): if v > 1: return Err.DOUBLE_SPEND # 15. Check if removals exist and were not previously spent. (unspent_db + diff_store + this_block) if peak is None or height == 0: fork_sub_h: int = -1 elif fork_point_with_peak is not None: fork_sub_h = fork_point_with_peak else: fork_sub_h = find_fork_point_in_chain( sub_blocks, peak, sub_blocks.sub_block_record(block.prev_header_hash)) if fork_sub_h == -1: coin_store_reorg_height = -1 else: last_sb_in_common = await sub_blocks.get_sub_block_from_db( sub_blocks.height_to_hash(uint32(fork_sub_h))) assert last_sb_in_common is not None coin_store_reorg_height = last_sb_in_common.height # Get additions and removals since (after) fork_h but not including this block additions_since_fork: Dict[bytes32, Tuple[Coin, uint32]] = {} removals_since_fork: Set[bytes32] = set() coinbases_since_fork: Dict[bytes32, uint32] = {} if height > 0: curr: Optional[FullBlock] = await block_store.get_full_block( block.prev_header_hash) assert curr is not None while curr.height > fork_sub_h: removals_in_curr, additions_in_curr = curr.tx_removals_and_additions( ) for c_name in removals_in_curr: removals_since_fork.add(c_name) for c in additions_in_curr: additions_since_fork[c.name()] = (c, curr.height) for coinbase_coin in curr.get_included_reward_coins(): additions_since_fork[coinbase_coin.name()] = (coinbase_coin, curr.height) coinbases_since_fork[coinbase_coin.name()] = curr.height if curr.height == 0: break curr = await block_store.get_full_block(curr.prev_header_hash) assert curr is not None removal_coin_records: Dict[bytes32, CoinRecord] = {} for rem in removals: if rem in additions_dic: # Ephemeral coin rem_coin: Coin = additions_dic[rem] new_unspent: CoinRecord = CoinRecord( rem_coin, height, uint32(0), False, False, block.foliage_block.timestamp, ) removal_coin_records[new_unspent.name] = new_unspent else: unspent = await coin_store.get_coin_record(rem) if unspent is not None and unspent.confirmed_block_index <= coin_store_reorg_height: # Spending something in the current chain, confirmed before fork # (We ignore all coins confirmed after fork) if unspent.spent == 1 and unspent.spent_block_index <= coin_store_reorg_height: # Check for coins spent in an ancestor block return Err.DOUBLE_SPEND removal_coin_records[unspent.name] = unspent else: # This coin is not in the current heaviest chain, so it must be in the fork if rem not in additions_since_fork: # Check for spending a coin that does not exist in this fork # TODO: fix this, there is a consensus bug here return Err.UNKNOWN_UNSPENT new_coin, confirmed_height = additions_since_fork[rem] new_coin_record: CoinRecord = CoinRecord( new_coin, confirmed_height, uint32(0), False, (rem in coinbases_since_fork), block.foliage_block.timestamp, ) removal_coin_records[new_coin_record.name] = new_coin_record # This check applies to both coins created before fork (pulled from coin_store), # and coins created after fork (additions_since_fork)> if rem in removals_since_fork: # This coin was spent in the fork return Err.DOUBLE_SPEND removed = 0 for unspent in removal_coin_records.values(): removed += unspent.coin.amount added = 0 for coin in additions: added += coin.amount # 16. Check that the total coin amount for added is <= removed if removed < added: return Err.MINTING_COIN fees = removed - added assert_fee_sum: uint64 = uint64(0) for npc in npc_list: if ConditionOpcode.ASSERT_FEE in npc.condition_dict: fee_list: List[ConditionVarPair] = npc.condition_dict[ ConditionOpcode.ASSERT_FEE] for cvp in fee_list: fee = int_from_bytes(cvp.vars[0]) assert_fee_sum = assert_fee_sum + fee # 17. Check that the assert fee sum <= fees if fees < assert_fee_sum: return Err.ASSERT_FEE_CONDITION_FAILED # 18. Check that the computed fees are equal to the fees in the block header if block.transactions_info.fees != fees: return Err.INVALID_BLOCK_FEE_AMOUNT # 19. Verify that removed coin puzzle_hashes match with calculated puzzle_hashes for unspent in removal_coin_records.values(): if unspent.coin.puzzle_hash != removals_puzzle_dic[unspent.name]: return Err.WRONG_PUZZLE_HASH # 20. Verify conditions # create hash_key list for aggsig check pairs_pks = [] pairs_msgs = [] for npc in npc_list: unspent = removal_coin_records[npc.coin_name] assert height is not None unspent = removal_coin_records[npc.coin_name] error = blockchain_check_conditions_dict( unspent, announcements, npc.condition_dict, prev_transaction_block_height, block.foliage_block.timestamp, ) if error: return error for pk, m in pkm_pairs_for_conditions_dict(npc.condition_dict, npc.coin_name): pairs_pks.append(pk) pairs_msgs.append(m) # 21. Verify aggregated signature # TODO: move this to pre_validate_blocks_multiprocessing so we can sync faster if not block.transactions_info.aggregated_signature: return Err.BAD_AGGREGATE_SIGNATURE if len(pairs_pks) == 0: if len( pairs_msgs ) != 0 or block.transactions_info.aggregated_signature != G2Element.infinity( ): return Err.BAD_AGGREGATE_SIGNATURE else: # noinspection PyTypeChecker validates = AugSchemeMPL.aggregate_verify( pairs_pks, pairs_msgs, block.transactions_info.aggregated_signature) if not validates: return Err.BAD_AGGREGATE_SIGNATURE return None
def get_signage_point_vdf_info( constants: ConsensusConstants, finished_sub_slots: List[EndOfSubSlotBundle], overflow: bool, prev_sb: Optional[SubBlockRecord], sub_blocks: BlockchainInterface, sp_total_iters: uint128, sp_iters: uint64, ): """ Returns the following information, for the VDF of the signage point at sp_total_iters. cc and rc challenge hash cc and rc input cc and rc iterations """ new_sub_slot: bool = len(finished_sub_slots) > 0 genesis_block: bool = prev_sb is None if new_sub_slot and not overflow: # Case 1: start from start of this slot. Case of no overflow slots. Also includes genesis block after empty # slot(s), but not overflowing rc_vdf_challenge: bytes32 = finished_sub_slots[ -1].reward_chain.get_hash() cc_vdf_challenge = finished_sub_slots[-1].challenge_chain.get_hash() sp_vdf_iters = sp_iters cc_vdf_input = ClassgroupElement.get_default_element() elif new_sub_slot and overflow and len(finished_sub_slots) > 1: # Case 2: start from start of prev slot. This is a rare case of empty prev slot. Includes genesis block after # 2 empty slots rc_vdf_challenge = finished_sub_slots[-2].reward_chain.get_hash() cc_vdf_challenge = finished_sub_slots[-2].challenge_chain.get_hash() sp_vdf_iters = sp_iters cc_vdf_input = ClassgroupElement.get_default_element() elif genesis_block: # Case 3: Genesis block case, first challenge rc_vdf_challenge = constants.GENESIS_CHALLENGE cc_vdf_challenge = constants.GENESIS_CHALLENGE sp_vdf_iters = sp_iters cc_vdf_input = ClassgroupElement.get_default_element() elif new_sub_slot and overflow and len(finished_sub_slots) == 1: # Case 4: Starting at prev will put us in the previous, sub-slot, since case 2 handled more empty slots assert prev_sb is not None curr: SubBlockRecord = prev_sb while not curr.first_in_sub_slot and curr.total_iters > sp_total_iters: curr = sub_blocks.sub_block_record(curr.prev_hash) if curr.total_iters < sp_total_iters: sp_vdf_iters = uint64(sp_total_iters - curr.total_iters) cc_vdf_input = curr.challenge_vdf_output rc_vdf_challenge = curr.reward_infusion_new_challenge else: assert curr.finished_reward_slot_hashes is not None sp_vdf_iters = sp_iters cc_vdf_input = ClassgroupElement.get_default_element() rc_vdf_challenge = curr.finished_reward_slot_hashes[-1] while not curr.first_in_sub_slot: curr = sub_blocks.sub_block_record(curr.prev_hash) assert curr.finished_challenge_slot_hashes is not None cc_vdf_challenge = curr.finished_challenge_slot_hashes[-1] elif not new_sub_slot and overflow: # Case 5: prev is in the same sub slot and also overflow. Starting at prev does not skip any sub slots assert prev_sb is not None curr = prev_sb # Collects the last two finished slots if curr.first_in_sub_slot: assert curr.finished_challenge_slot_hashes is not None assert curr.finished_reward_slot_hashes is not None found_sub_slots = list( reversed( list( zip( curr.finished_challenge_slot_hashes, curr.finished_reward_slot_hashes, )))) else: found_sub_slots = [] sp_pre_sb: Optional[SubBlockRecord] = None while len(found_sub_slots) < 2 and curr.height > 0: if sp_pre_sb is None and curr.total_iters < sp_total_iters: sp_pre_sb = curr curr = sub_blocks.sub_block_record(curr.prev_hash) if curr.first_in_sub_slot: assert curr.finished_challenge_slot_hashes is not None assert curr.finished_reward_slot_hashes is not None found_sub_slots += list( reversed( list( zip( curr.finished_challenge_slot_hashes, curr.finished_reward_slot_hashes, )))) if sp_pre_sb is None and curr.total_iters < sp_total_iters: sp_pre_sb = curr if sp_pre_sb is not None: sp_vdf_iters = uint64(sp_total_iters - sp_pre_sb.total_iters) cc_vdf_input = sp_pre_sb.challenge_vdf_output rc_vdf_challenge = sp_pre_sb.reward_infusion_new_challenge else: sp_vdf_iters = sp_iters cc_vdf_input = ClassgroupElement.get_default_element() rc_vdf_challenge = found_sub_slots[1][1] cc_vdf_challenge = found_sub_slots[1][0] elif not new_sub_slot and not overflow: # Case 6: prev is in the same sub slot. Starting at prev does not skip any sub slots. We do not need # to go back another sub slot, because it's not overflow, so the VDF to signage point is this sub-slot. assert prev_sb is not None curr = prev_sb while not curr.first_in_sub_slot and curr.total_iters > sp_total_iters: curr = sub_blocks.sub_block_record(curr.prev_hash) if curr.total_iters < sp_total_iters: sp_vdf_iters = uint64(sp_total_iters - curr.total_iters) cc_vdf_input = curr.challenge_vdf_output rc_vdf_challenge = curr.reward_infusion_new_challenge else: assert curr.finished_reward_slot_hashes is not None sp_vdf_iters = sp_iters cc_vdf_input = ClassgroupElement.get_default_element() rc_vdf_challenge = curr.finished_reward_slot_hashes[-1] while not curr.first_in_sub_slot: curr = sub_blocks.sub_block_record(curr.prev_hash) assert curr.finished_challenge_slot_hashes is not None cc_vdf_challenge = curr.finished_challenge_slot_hashes[-1] else: # All cases are handled above assert False return ( cc_vdf_challenge, rc_vdf_challenge, cc_vdf_input, ClassgroupElement.get_default_element(), sp_vdf_iters, sp_vdf_iters, )
def next_sub_epoch_summary( constants: ConsensusConstants, sub_blocks: BlockchainInterface, required_iters: uint64, block: Union[UnfinishedBlock, FullBlock], can_finish_soon: bool = False, ) -> Optional[SubEpochSummary]: """ Returns the sub-epoch summary that can be included in the sub-block after block. If it should include one. Block must be eligible to be the last sub-block in the epoch. If not, returns None. Assumes that there is a new slot ending after block. Args: constants: consensus constants being used for this chain sub_blocks: interface to cached SBR required_iters: required iters of the proof of space in block block: the (potentially) last sub-block in the new epoch can_finish_soon: this is useful when sending SES to timelords. We might not be able to finish it, but we will soon (within MAX_SUB_SLOT_SUB_BLOCKS) Returns: object: the new sub-epoch summary """ signage_point_index = block.reward_chain_sub_block.signage_point_index prev_sb: Optional[SubBlockRecord] = sub_blocks.try_sub_block(block.prev_header_hash) if prev_sb is None or prev_sb.height == 0: return None if len(block.finished_sub_slots) > 0 and block.finished_sub_slots[0].challenge_chain.new_difficulty is not None: # We just included a sub-epoch summary return None assert prev_sb is not None # This is the ssi of the current block sub_slot_iters = get_next_sub_slot_iters( constants, sub_blocks, prev_sb.prev_hash, prev_sb.height, prev_sb.sub_slot_iters, prev_sb.deficit, len(block.finished_sub_slots) > 0, prev_sb.sp_total_iters(constants), ) overflow = is_overflow_sub_block(constants, signage_point_index) deficit = calculate_deficit( constants, uint32(prev_sb.height + 1), prev_sb, overflow, len(block.finished_sub_slots), ) can_finish_se, can_finish_epoch = can_finish_sub_and_full_epoch( constants, uint32(prev_sb.height + 1), deficit, sub_blocks, prev_sb.header_hash if prev_sb is not None else None, can_finish_soon, ) # can't finish se, no summary if not can_finish_se: return None next_difficulty = None next_sub_slot_iters = None # if can finish epoch, new difficulty and ssi if can_finish_epoch: sp_iters = calculate_sp_iters(constants, sub_slot_iters, signage_point_index) ip_iters = calculate_ip_iters(constants, sub_slot_iters, signage_point_index, required_iters) next_difficulty = get_next_difficulty( constants, sub_blocks, block.prev_header_hash, uint32(prev_sb.height + 1), uint64(prev_sb.weight - sub_blocks.sub_block_record(prev_sb.prev_hash).weight), deficit, True, uint128(block.total_iters - ip_iters + sp_iters - (sub_slot_iters if overflow else 0)), True, ) next_sub_slot_iters = get_next_sub_slot_iters( constants, sub_blocks, block.prev_header_hash, uint32(prev_sb.height + 1), sub_slot_iters, deficit, True, uint128(block.total_iters - ip_iters + sp_iters - (sub_slot_iters if overflow else 0)), True, ) return make_sub_epoch_summary( constants, sub_blocks, uint32(prev_sb.height + 2), prev_sb, next_difficulty, next_sub_slot_iters, )
def create_foliage( constants: ConsensusConstants, reward_sub_block: RewardChainSubBlockUnfinished, spend_bundle: Optional[SpendBundle], prev_sub_block: Optional[SubBlockRecord], sub_blocks: BlockchainInterface, total_iters_sp: uint128, timestamp: uint64, farmer_reward_puzzlehash: bytes32, pool_target: PoolTarget, get_plot_signature: Callable[[bytes32, G1Element], G2Element], get_pool_signature: Callable[[PoolTarget, G1Element], G2Element], seed: bytes32 = b"", ) -> Tuple[FoliageSubBlock, Optional[FoliageBlock], Optional[TransactionsInfo], Optional[SerializedProgram]]: """ Creates a foliage for a given reward chain sub block. This may or may not be a block. In the case of a block, the return values are not None. This is called at the signage point, so some of this information may be tweaked at the infusion point. Args: constants: consensus constants being used for this chain reward_sub_block: the reward sub block to look at, potentially at the signage point spend_bundle: the spend bundle including all transactions prev_sub_block: the previous sub-block at the signage point sub_blocks: dict from header hash to sub-blocks, of all ancestor sub-blocks total_iters_sp: total iters at the signage point timestamp: timestamp to put into the foliage block farmer_reward_puzzlehash: where to pay out farming reward pool_target: where to pay out pool reward get_plot_signature: retrieve the signature corresponding to the plot public key get_pool_signature: retrieve the signature corresponding to the pool public key seed: seed to randomize block """ if prev_sub_block is not None: res = get_prev_block(prev_sub_block, sub_blocks, total_iters_sp) is_block: bool = res[0] prev_block: Optional[SubBlockRecord] = res[1] else: # Genesis is a block prev_block = None is_block = True random.seed(seed) # Use the extension data to create different blocks based on header hash extension_data: bytes32 = random.randint(0, 100000000).to_bytes(32, "big") if prev_sub_block is None: height: uint32 = uint32(0) else: height = uint32(prev_sub_block.height + 1) # Create filter byte_array_tx: List[bytes32] = [] tx_additions: List[Coin] = [] tx_removals: List[bytes32] = [] pool_target_signature: Optional[G2Element] = get_pool_signature( pool_target, reward_sub_block.proof_of_space.pool_public_key) assert pool_target_signature is not None foliage_sub_block_data = FoliageSubBlockData( reward_sub_block.get_hash(), pool_target, pool_target_signature, farmer_reward_puzzlehash, extension_data, ) foliage_sub_block_signature: G2Element = get_plot_signature( foliage_sub_block_data.get_hash(), reward_sub_block.proof_of_space.plot_public_key, ) prev_sub_block_hash: bytes32 = constants.GENESIS_CHALLENGE if height != 0: assert prev_sub_block is not None prev_sub_block_hash = prev_sub_block.header_hash solution_program: Optional[SerializedProgram] = None if is_block: spend_bundle_fees: int = 0 aggregate_sig: G2Element = G2Element.infinity() cost = uint64(0) if spend_bundle is not None: solution_program = best_solution_program(spend_bundle) spend_bundle_fees = spend_bundle.fees() aggregate_sig = spend_bundle.aggregated_signature # Calculate the cost of transactions if solution_program is not None: result: CostResult = calculate_cost_of_program( solution_program, constants.CLVM_COST_RATIO_CONSTANT) cost = result.cost # TODO: prev generators root reward_claims_incorporated = [] if height > 0: assert prev_block is not None assert prev_sub_block is not None curr: SubBlockRecord = prev_sub_block while not curr.is_block: curr = sub_blocks.sub_block_record(curr.prev_hash) assert curr.fees is not None pool_coin = create_pool_coin( curr.height, curr.pool_puzzle_hash, calculate_pool_reward(curr.height), ) farmer_coin = create_farmer_coin( curr.height, curr.farmer_puzzle_hash, uint64(calculate_base_farmer_reward(curr.height) + curr.fees), ) assert curr.header_hash == prev_block.header_hash reward_claims_incorporated += [pool_coin, farmer_coin] if curr.height > 0: curr = sub_blocks.sub_block_record(curr.prev_hash) # Prev block is not genesis while not curr.is_block: pool_coin = create_pool_coin( curr.height, curr.pool_puzzle_hash, calculate_pool_reward(curr.height), ) farmer_coin = create_farmer_coin( curr.height, curr.farmer_puzzle_hash, calculate_base_farmer_reward(curr.height), ) reward_claims_incorporated += [pool_coin, farmer_coin] curr = sub_blocks.sub_block_record(curr.prev_hash) additions: List[Coin] = reward_claims_incorporated.copy() npc_list = [] if solution_program is not None: error, npc_list, _ = get_name_puzzle_conditions( solution_program, False) additions += additions_for_npc(npc_list) for coin in additions: tx_additions.append(coin) byte_array_tx.append(bytearray(coin.puzzle_hash)) for npc in npc_list: tx_removals.append(npc.coin_name) byte_array_tx.append(bytearray(npc.coin_name)) bip158: PyBIP158 = PyBIP158(byte_array_tx) encoded = bytes(bip158.GetEncoded()) removal_merkle_set = MerkleSet() addition_merkle_set = MerkleSet() # Create removal Merkle set for coin_name in tx_removals: removal_merkle_set.add_already_hashed(coin_name) # Create addition Merkle set puzzlehash_coin_map: Dict[bytes32, List[Coin]] = {} for coin in tx_additions: if coin.puzzle_hash in puzzlehash_coin_map: puzzlehash_coin_map[coin.puzzle_hash].append(coin) else: puzzlehash_coin_map[coin.puzzle_hash] = [coin] # Addition Merkle set contains puzzlehash and hash of all coins with that puzzlehash for puzzle, coins in puzzlehash_coin_map.items(): addition_merkle_set.add_already_hashed(puzzle) addition_merkle_set.add_already_hashed(hash_coin_list(coins)) additions_root = addition_merkle_set.get_root() removals_root = removal_merkle_set.get_root() generator_hash = solution_program.get_tree_hash( ) if solution_program is not None else bytes32([0] * 32) filter_hash: bytes32 = std_hash(encoded) transactions_info: Optional[TransactionsInfo] = TransactionsInfo( bytes([0] * 32), generator_hash, aggregate_sig, uint64(spend_bundle_fees), cost, reward_claims_incorporated, ) if prev_block is None: prev_block_hash: bytes32 = constants.GENESIS_CHALLENGE else: prev_block_hash = prev_block.header_hash assert transactions_info is not None foliage_block: Optional[FoliageBlock] = FoliageBlock( prev_block_hash, timestamp, filter_hash, additions_root, removals_root, transactions_info.get_hash(), ) assert foliage_block is not None foliage_block_hash: Optional[bytes32] = foliage_block.get_hash() foliage_block_signature: Optional[G2Element] = get_plot_signature( foliage_block_hash, reward_sub_block.proof_of_space.plot_public_key) assert foliage_block_signature is not None else: foliage_block_hash = None foliage_block_signature = None foliage_block = None transactions_info = None assert (foliage_block_hash is None) == (foliage_block_signature is None) foliage_sub_block = FoliageSubBlock( prev_sub_block_hash, reward_sub_block.get_hash(), foliage_sub_block_data, foliage_sub_block_signature, foliage_block_hash, foliage_block_signature, ) return foliage_sub_block, foliage_block, transactions_info, solution_program
def validate_unfinished_header_block( constants: ConsensusConstants, sub_blocks: BlockchainInterface, header_block: UnfinishedHeaderBlock, check_filter: bool, expected_difficulty: uint64, expected_sub_slot_iters: uint64, skip_overflow_last_ss_validation: bool = False, skip_vdf_is_valid: bool = False, ) -> Tuple[Optional[uint64], Optional[ValidationError]]: """ Validates an unfinished header block. This is a block without the infusion VDFs (unfinished) and without transactions and transaction info (header). Returns (required_iters, error). This method is meant to validate only the unfinished part of the sub-block. However, the finished_sub_slots refers to all sub-slots that were finishes from the previous sub-block's infusion point, up to this sub-blocks infusion point. Therefore, in the case where this is an overflow sub-block, and the last sub-slot is not yet released, header_block.finished_sub_slots will be missing one sub-slot. In this case, skip_overflow_last_ss_validation must be set to True. This will skip validation of end of slots, sub-epochs, and lead to other small tweaks in validation. """ # 1. Check that the previous block exists in the blockchain, or that it is correct prev_sb = sub_blocks.try_sub_block(header_block.prev_header_hash) genesis_block = prev_sb is None if genesis_block and header_block.prev_header_hash != constants.GENESIS_CHALLENGE: return None, ValidationError(Err.INVALID_PREV_BLOCK_HASH) overflow = is_overflow_sub_block( constants, header_block.reward_chain_sub_block.signage_point_index) if skip_overflow_last_ss_validation and overflow: finished_sub_slots_since_prev = len( header_block.finished_sub_slots) + 1 else: finished_sub_slots_since_prev = len(header_block.finished_sub_slots) new_sub_slot: bool = finished_sub_slots_since_prev > 0 can_finish_se: bool = False can_finish_epoch: bool = False if genesis_block: height: uint32 = uint32(0) assert expected_difficulty == constants.DIFFICULTY_STARTING assert expected_sub_slot_iters == constants.SUB_SLOT_ITERS_STARTING else: assert prev_sb is not None height = uint32(prev_sb.height + 1) if prev_sb.sub_epoch_summary_included is not None: can_finish_se, can_finish_epoch = False, False else: if new_sub_slot: can_finish_se, can_finish_epoch = can_finish_sub_and_full_epoch( constants, prev_sb.height, prev_sb.deficit, sub_blocks, prev_sb.prev_hash, False, ) else: can_finish_se = False can_finish_epoch = False # 2. Check finished slots that have been crossed since prev_sb ses_hash: Optional[bytes32] = None if new_sub_slot and not skip_overflow_last_ss_validation: # Finished a slot(s) since previous block. The first sub-slot must have at least one sub-block, and all # subsequent sub-slots must be empty for finished_sub_slot_n, sub_slot in enumerate( header_block.finished_sub_slots): # Start of slot challenge is fetched from SP challenge_hash: bytes32 = sub_slot.challenge_chain.challenge_chain_end_of_slot_vdf.challenge if finished_sub_slot_n == 0: if genesis_block: # 2a. check sub-slot challenge hash for genesis block if challenge_hash != constants.GENESIS_CHALLENGE: return None, ValidationError( Err.INVALID_PREV_CHALLENGE_SLOT_HASH) else: assert prev_sb is not None curr: SubBlockRecord = prev_sb while not curr.first_in_sub_slot: curr = sub_blocks.sub_block_record(curr.prev_hash) assert curr.finished_challenge_slot_hashes is not None # 2b. check sub-slot challenge hash for non-genesis block if not curr.finished_challenge_slot_hashes[ -1] == challenge_hash: print(curr.finished_challenge_slot_hashes[-1], challenge_hash) return None, ValidationError( Err.INVALID_PREV_CHALLENGE_SLOT_HASH) else: # 2c. check sub-slot challenge hash for empty slot if (not header_block.finished_sub_slots[ finished_sub_slot_n - 1].challenge_chain.get_hash() == challenge_hash): return None, ValidationError( Err.INVALID_PREV_CHALLENGE_SLOT_HASH) if genesis_block: # 2d. Validate that genesis block has no ICC if sub_slot.infused_challenge_chain is not None: return None, ValidationError(Err.SHOULD_NOT_HAVE_ICC) else: assert prev_sb is not None icc_iters_committed: Optional[uint64] = None icc_iters_proof: Optional[uint64] = None icc_challenge_hash: Optional[bytes32] = None icc_vdf_input = None if prev_sb.deficit < constants.MIN_SUB_BLOCKS_PER_CHALLENGE_BLOCK: # There should be no ICC chain if the last sub block's deficit is 16 # Prev sb's deficit is 0, 1, 2, 3, or 4 if finished_sub_slot_n == 0: # This is the first sub slot after the last sb, which must have deficit 1-4, and thus an ICC curr = prev_sb while not curr.is_challenge_sub_block( constants) and not curr.first_in_sub_slot: curr = sub_blocks.sub_block_record(curr.prev_hash) if curr.is_challenge_sub_block(constants): icc_challenge_hash = curr.challenge_block_info_hash icc_iters_committed = uint64( prev_sb.sub_slot_iters - curr.ip_iters(constants)) else: assert curr.finished_infused_challenge_slot_hashes is not None icc_challenge_hash = curr.finished_infused_challenge_slot_hashes[ -1] icc_iters_committed = prev_sb.sub_slot_iters icc_iters_proof = uint64(prev_sb.sub_slot_iters - prev_sb.ip_iters(constants)) if prev_sb.is_challenge_sub_block(constants): icc_vdf_input = ClassgroupElement.get_default_element( ) else: icc_vdf_input = prev_sb.infused_challenge_vdf_output else: # This is not the first sub slot after the last sub block, so we might not have an ICC if (header_block.finished_sub_slots[ finished_sub_slot_n - 1].reward_chain.deficit < constants.MIN_SUB_BLOCKS_PER_CHALLENGE_BLOCK): finished_ss = header_block.finished_sub_slots[ finished_sub_slot_n - 1] assert finished_ss.infused_challenge_chain is not None # Only sets the icc iff the previous sub slots deficit is 4 or less icc_challenge_hash = finished_ss.infused_challenge_chain.get_hash( ) icc_iters_committed = prev_sb.sub_slot_iters icc_iters_proof = icc_iters_committed icc_vdf_input = ClassgroupElement.get_default_element( ) # 2e. Validate that there is not icc iff icc_challenge hash is None assert (sub_slot.infused_challenge_chain is None) == (icc_challenge_hash is None) if sub_slot.infused_challenge_chain is not None: assert icc_vdf_input is not None assert icc_iters_proof is not None assert icc_challenge_hash is not None assert sub_slot.proofs.infused_challenge_chain_slot_proof is not None # 2f. Check infused challenge chain sub-slot VDF # Only validate from prev_sb to optimize target_vdf_info = VDFInfo( icc_challenge_hash, icc_iters_proof, sub_slot.infused_challenge_chain. infused_challenge_chain_end_of_slot_vdf.output, ) if sub_slot.infused_challenge_chain.infused_challenge_chain_end_of_slot_vdf != dataclasses.replace( target_vdf_info, number_of_iterations=icc_iters_committed, ): return None, ValidationError(Err.INVALID_ICC_EOS_VDF) if not skip_vdf_is_valid and not sub_slot.proofs.infused_challenge_chain_slot_proof.is_valid( constants, icc_vdf_input, target_vdf_info, None): return None, ValidationError(Err.INVALID_ICC_EOS_VDF) if sub_slot.reward_chain.deficit == constants.MIN_SUB_BLOCKS_PER_CHALLENGE_BLOCK: # 2g. Check infused challenge sub-slot hash in challenge chain, deficit 16 if (sub_slot.infused_challenge_chain.get_hash() != sub_slot.challenge_chain. infused_challenge_chain_sub_slot_hash): return None, ValidationError( Err.INVALID_ICC_HASH_CC) else: # 2h. Check infused challenge sub-slot hash not included for other deficits if sub_slot.challenge_chain.infused_challenge_chain_sub_slot_hash is not None: return None, ValidationError( Err.INVALID_ICC_HASH_CC) # 2i. Check infused challenge sub-slot hash in reward sub-slot if (sub_slot.infused_challenge_chain.get_hash() != sub_slot.reward_chain. infused_challenge_chain_sub_slot_hash): return None, ValidationError(Err.INVALID_ICC_HASH_RC) else: # 2j. If no icc, check that the cc doesn't include it if sub_slot.challenge_chain.infused_challenge_chain_sub_slot_hash is not None: return None, ValidationError(Err.INVALID_ICC_HASH_CC) # 2k. If no icc, check that the cc doesn't include it if sub_slot.reward_chain.infused_challenge_chain_sub_slot_hash is not None: return None, ValidationError(Err.INVALID_ICC_HASH_RC) if sub_slot.challenge_chain.subepoch_summary_hash is not None: assert ses_hash is None # Only one of the slots can have it ses_hash = sub_slot.challenge_chain.subepoch_summary_hash # 2l. check sub-epoch summary hash is None for empty slots if finished_sub_slot_n != 0: if sub_slot.challenge_chain.subepoch_summary_hash is not None: return None, ValidationError( Err.INVALID_SUB_EPOCH_SUMMARY_HASH) if can_finish_epoch and sub_slot.challenge_chain.subepoch_summary_hash is not None: # 2m. Check new difficulty and ssi if sub_slot.challenge_chain.new_sub_slot_iters != expected_sub_slot_iters: return None, ValidationError( Err.INVALID_NEW_SUB_SLOT_ITERS) if sub_slot.challenge_chain.new_difficulty != expected_difficulty: return None, ValidationError(Err.INVALID_NEW_DIFFICULTY) else: # 2n. Check new difficulty and ssi are None if we don't finish epoch if sub_slot.challenge_chain.new_sub_slot_iters is not None: return None, ValidationError( Err.INVALID_NEW_SUB_SLOT_ITERS) if sub_slot.challenge_chain.new_difficulty is not None: return None, ValidationError(Err.INVALID_NEW_DIFFICULTY) # 2o. Check challenge sub-slot hash in reward sub-slot if sub_slot.challenge_chain.get_hash( ) != sub_slot.reward_chain.challenge_chain_sub_slot_hash: return ( None, ValidationError( Err.INVALID_CHALLENGE_SLOT_HASH_RC, "sub-slot hash in reward sub-slot mismatch", ), ) eos_vdf_iters: uint64 = expected_sub_slot_iters cc_start_element: ClassgroupElement = ClassgroupElement.get_default_element( ) cc_eos_vdf_challenge: bytes32 = challenge_hash if genesis_block: if finished_sub_slot_n == 0: # First block, one empty slot. prior_point is the initial challenge rc_eos_vdf_challenge: bytes32 = constants.GENESIS_CHALLENGE cc_eos_vdf_challenge = constants.GENESIS_CHALLENGE else: # First block, but have at least two empty slots rc_eos_vdf_challenge = header_block.finished_sub_slots[ finished_sub_slot_n - 1].reward_chain.get_hash() else: assert prev_sb is not None if finished_sub_slot_n == 0: # No empty slots, so the starting point of VDF is the last reward block. Uses # the same IPS as the previous block, since it's the same slot rc_eos_vdf_challenge = prev_sb.reward_infusion_new_challenge eos_vdf_iters = uint64(prev_sb.sub_slot_iters - prev_sb.ip_iters(constants)) cc_start_element = prev_sb.challenge_vdf_output else: # At least one empty slot, so use previous slot hash. IPS might change because it's a new slot rc_eos_vdf_challenge = header_block.finished_sub_slots[ finished_sub_slot_n - 1].reward_chain.get_hash() # 2p. Check end of reward slot VDF target_vdf_info = VDFInfo( rc_eos_vdf_challenge, eos_vdf_iters, sub_slot.reward_chain.end_of_slot_vdf.output, ) if not skip_vdf_is_valid and not sub_slot.proofs.reward_chain_slot_proof.is_valid( constants, ClassgroupElement.get_default_element(), sub_slot.reward_chain.end_of_slot_vdf, target_vdf_info, ): return None, ValidationError(Err.INVALID_RC_EOS_VDF) # 2q. Check challenge chain sub-slot VDF partial_cc_vdf_info = VDFInfo( cc_eos_vdf_challenge, eos_vdf_iters, sub_slot.challenge_chain.challenge_chain_end_of_slot_vdf. output, ) if genesis_block: cc_eos_vdf_info_iters = constants.SUB_SLOT_ITERS_STARTING else: assert prev_sb is not None if finished_sub_slot_n == 0: cc_eos_vdf_info_iters = prev_sb.sub_slot_iters else: cc_eos_vdf_info_iters = expected_sub_slot_iters # Check that the modified data is correct if sub_slot.challenge_chain.challenge_chain_end_of_slot_vdf != dataclasses.replace( partial_cc_vdf_info, number_of_iterations=cc_eos_vdf_info_iters, ): return None, ValidationError( Err.INVALID_CC_EOS_VDF, "wrong challenge chain end of slot vdf") # Pass in None for target info since we are only checking the proof from the temporary point, # but the challenge_chain_end_of_slot_vdf actually starts from the start of slot (for light clients) if not skip_vdf_is_valid and not sub_slot.proofs.challenge_chain_slot_proof.is_valid( constants, cc_start_element, partial_cc_vdf_info, None): return None, ValidationError(Err.INVALID_CC_EOS_VDF) if genesis_block: # 2r. Check deficit (MIN_SUB.. deficit edge case for genesis block) if sub_slot.reward_chain.deficit != constants.MIN_SUB_BLOCKS_PER_CHALLENGE_BLOCK: return ( None, ValidationError( Err.INVALID_DEFICIT, f"genesis, expected deficit {constants.MIN_SUB_BLOCKS_PER_CHALLENGE_BLOCK}", ), ) else: assert prev_sb is not None if prev_sb.deficit == 0: # 2s. If prev sb had deficit 0, resets deficit to MIN_SUB_BLOCK_PER_CHALLENGE_BLOCK if sub_slot.reward_chain.deficit != constants.MIN_SUB_BLOCKS_PER_CHALLENGE_BLOCK: log.error( constants.MIN_SUB_BLOCKS_PER_CHALLENGE_BLOCK, ) return ( None, ValidationError( Err.INVALID_DEFICIT, f"expected deficit {constants.MIN_SUB_BLOCKS_PER_CHALLENGE_BLOCK}, saw " f"{sub_slot.reward_chain.deficit}", ), ) else: # 2t. Otherwise, deficit stays the same at the slot ends, cannot reset until 0 if sub_slot.reward_chain.deficit != prev_sb.deficit: return None, ValidationError( Err.INVALID_DEFICIT, "deficit is wrong at slot end") # 3. Check sub-epoch summary # Note that the subepoch summary is the summary of the previous subepoch (not the one that just finished) if not skip_overflow_last_ss_validation: if ses_hash is not None: # 3a. Check that genesis block does not have sub-epoch summary if genesis_block: return ( None, ValidationError( Err.INVALID_SUB_EPOCH_SUMMARY_HASH, "genesis with sub-epoch-summary hash", ), ) assert prev_sb is not None # 3b. Check that we finished a slot and we finished a sub-epoch if not new_sub_slot or not can_finish_se: return ( None, ValidationError( Err.INVALID_SUB_EPOCH_SUMMARY_HASH, f"new sub-slot: {new_sub_slot} finishes sub-epoch {can_finish_se}", ), ) # 3c. Check the actual sub-epoch is correct expected_sub_epoch_summary = make_sub_epoch_summary( constants, sub_blocks, height, sub_blocks.sub_block_record(prev_sb.prev_hash), expected_difficulty if can_finish_epoch else None, expected_sub_slot_iters if can_finish_epoch else None, ) expected_hash = expected_sub_epoch_summary.get_hash() if expected_hash != ses_hash: log.error(f"{expected_sub_epoch_summary}") return ( None, ValidationError( Err.INVALID_SUB_EPOCH_SUMMARY, f"expected ses hash: {expected_hash} got {ses_hash} ", ), ) elif new_sub_slot and not genesis_block: # 3d. Check that we don't have to include a sub-epoch summary if can_finish_se or can_finish_epoch: return ( None, ValidationError( Err.INVALID_SUB_EPOCH_SUMMARY, "block finishes sub-epoch but ses-hash is None", ), ) # 4. Check if the number of sub-blocks is less than the max if not new_sub_slot and not genesis_block: assert prev_sb is not None num_sub_blocks = 2 # This includes the current sub-block and the prev sub-block curr = prev_sb while not curr.first_in_sub_slot: num_sub_blocks += 1 curr = sub_blocks.sub_block_record(curr.prev_hash) if num_sub_blocks > constants.MAX_SUB_SLOT_SUB_BLOCKS: return None, ValidationError(Err.TOO_MANY_SUB_BLOCKS) # If sub_block state is correct, we should always find a challenge here # This computes what the challenge should be for this sub-block challenge = get_block_challenge( constants, header_block, sub_blocks, genesis_block, overflow, skip_overflow_last_ss_validation, ) # 5a. Check proof of space if challenge != header_block.reward_chain_sub_block.pos_ss_cc_challenge_hash: log.error(f"Finished slots: {header_block.finished_sub_slots}") log.error( f"Data: {genesis_block} {overflow} {skip_overflow_last_ss_validation} {header_block.total_iters} " f"{header_block.reward_chain_sub_block.signage_point_index}" f"Prev: {prev_sb}") log.error( f"Challenge {challenge} provided {header_block.reward_chain_sub_block.pos_ss_cc_challenge_hash}" ) return None, ValidationError(Err.INVALID_CC_CHALLENGE) # 5b. Check proof of space if header_block.reward_chain_sub_block.challenge_chain_sp_vdf is None: # Edge case of first sp (start of slot), where sp_iters == 0 cc_sp_hash: bytes32 = challenge else: cc_sp_hash = header_block.reward_chain_sub_block.challenge_chain_sp_vdf.output.get_hash( ) q_str: Optional[ bytes32] = header_block.reward_chain_sub_block.proof_of_space.verify_and_get_quality_string( constants, challenge, cc_sp_hash) if q_str is None: return None, ValidationError(Err.INVALID_POSPACE) # 6. check signage point index # no need to check negative values as this is uint 8 if header_block.reward_chain_sub_block.signage_point_index >= constants.NUM_SPS_SUB_SLOT: return None, ValidationError(Err.INVALID_SP_INDEX) # Note that required iters might be from the previous slot (if we are in an overflow sub-block) required_iters: uint64 = calculate_iterations_quality( q_str, header_block.reward_chain_sub_block.proof_of_space.size, expected_difficulty, cc_sp_hash, ) # 7. check signage point index # no need to check negative values as this is uint8. (Assumes types are checked) if header_block.reward_chain_sub_block.signage_point_index >= constants.NUM_SPS_SUB_SLOT: return None, ValidationError(Err.INVALID_SP_INDEX) # 8a. check signage point index 0 has no cc sp if (header_block.reward_chain_sub_block.signage_point_index == 0) != ( header_block.reward_chain_sub_block.challenge_chain_sp_vdf is None): return None, ValidationError(Err.INVALID_SP_INDEX) # 8b. check signage point index 0 has no rc sp if (header_block.reward_chain_sub_block.signage_point_index == 0) != ( header_block.reward_chain_sub_block.reward_chain_sp_vdf is None): return None, ValidationError(Err.INVALID_SP_INDEX) sp_iters: uint64 = calculate_sp_iters( constants, expected_sub_slot_iters, header_block.reward_chain_sub_block.signage_point_index, ) ip_iters: uint64 = calculate_ip_iters( constants, expected_sub_slot_iters, header_block.reward_chain_sub_block.signage_point_index, required_iters, ) if header_block.reward_chain_sub_block.challenge_chain_sp_vdf is None: # Blocks with very low required iters are not overflow blocks assert not overflow # 9. Check no overflows in the first sub-slot of a new epoch # (although they are OK in the second sub-slot), this is important if overflow and can_finish_epoch: if finished_sub_slots_since_prev < 2: return None, ValidationError( Err.NO_OVERFLOWS_IN_FIRST_SUB_SLOT_NEW_EPOCH) # 10. Check total iters if genesis_block: total_iters: uint128 = uint128(expected_sub_slot_iters * finished_sub_slots_since_prev) else: assert prev_sb is not None if new_sub_slot: total_iters = prev_sb.total_iters # Add the rest of the slot of prev_sb total_iters = uint128(total_iters + prev_sb.sub_slot_iters - prev_sb.ip_iters(constants)) # Add other empty slots total_iters = uint128(total_iters + (expected_sub_slot_iters * (finished_sub_slots_since_prev - 1))) else: # Slot iters is guaranteed to be the same for header_block and prev_sb # This takes the beginning of the slot, and adds ip_iters total_iters = uint128(prev_sb.total_iters - prev_sb.ip_iters(constants)) total_iters = uint128(total_iters + ip_iters) if total_iters != header_block.reward_chain_sub_block.total_iters: return ( None, ValidationError( Err.INVALID_TOTAL_ITERS, f"expected {total_iters} got {header_block.reward_chain_sub_block.total_iters}", ), ) sp_total_iters: uint128 = uint128(total_iters - ip_iters + sp_iters - ( expected_sub_slot_iters if overflow else 0)) if overflow and skip_overflow_last_ss_validation: dummy_vdf_info = VDFInfo( bytes32([0] * 32), uint64(1), ClassgroupElement.get_default_element(), ) dummy_sub_slot = EndOfSubSlotBundle( ChallengeChainSubSlot(dummy_vdf_info, None, None, None, None), None, RewardChainSubSlot(dummy_vdf_info, bytes32([0] * 32), None, uint8(0)), SubSlotProofs(VDFProof(uint8(0), b""), None, VDFProof(uint8(0), b"")), ) sub_slots_to_pass_in = header_block.finished_sub_slots + [ dummy_sub_slot ] else: sub_slots_to_pass_in = header_block.finished_sub_slots ( cc_vdf_challenge, rc_vdf_challenge, cc_vdf_input, rc_vdf_input, cc_vdf_iters, rc_vdf_iters, ) = get_signage_point_vdf_info( constants, sub_slots_to_pass_in, overflow, prev_sb, sub_blocks, sp_total_iters, sp_iters, ) # 11. Check reward chain sp proof if sp_iters != 0: assert (header_block.reward_chain_sub_block.reward_chain_sp_vdf is not None and header_block.reward_chain_sp_proof is not None) target_vdf_info = VDFInfo( rc_vdf_challenge, rc_vdf_iters, header_block.reward_chain_sub_block.reward_chain_sp_vdf.output, ) if not skip_vdf_is_valid and not header_block.reward_chain_sp_proof.is_valid( constants, rc_vdf_input, header_block.reward_chain_sub_block.reward_chain_sp_vdf, target_vdf_info, ): return None, ValidationError(Err.INVALID_RC_SP_VDF) rc_sp_hash = header_block.reward_chain_sub_block.reward_chain_sp_vdf.output.get_hash( ) else: # Edge case of first sp (start of slot), where sp_iters == 0 assert overflow is not None if header_block.reward_chain_sub_block.reward_chain_sp_vdf is not None: return None, ValidationError(Err.INVALID_RC_SP_VDF) if new_sub_slot: rc_sp_hash = header_block.finished_sub_slots[ -1].reward_chain.get_hash() else: if genesis_block: rc_sp_hash = constants.GENESIS_CHALLENGE else: assert prev_sb is not None curr = prev_sb while not curr.first_in_sub_slot: curr = sub_blocks.sub_block_record(curr.prev_hash) assert curr.finished_reward_slot_hashes is not None rc_sp_hash = curr.finished_reward_slot_hashes[-1] # 12. Check reward chain sp signature if not AugSchemeMPL.verify( header_block.reward_chain_sub_block.proof_of_space.plot_public_key, rc_sp_hash, header_block.reward_chain_sub_block.reward_chain_sp_signature, ): return None, ValidationError(Err.INVALID_RC_SIGNATURE) # 13. Check cc sp vdf if sp_iters != 0: assert header_block.reward_chain_sub_block.challenge_chain_sp_vdf is not None assert header_block.challenge_chain_sp_proof is not None target_vdf_info = VDFInfo( cc_vdf_challenge, cc_vdf_iters, header_block.reward_chain_sub_block.challenge_chain_sp_vdf.output, ) if header_block.reward_chain_sub_block.challenge_chain_sp_vdf != dataclasses.replace( target_vdf_info, number_of_iterations=sp_iters, ): return None, ValidationError(Err.INVALID_CC_SP_VDF) if not skip_vdf_is_valid and not header_block.challenge_chain_sp_proof.is_valid( constants, cc_vdf_input, target_vdf_info, None): return None, ValidationError(Err.INVALID_CC_SP_VDF) else: assert overflow is not None if header_block.reward_chain_sub_block.challenge_chain_sp_vdf is not None: return None, ValidationError(Err.INVALID_CC_SP_VDF) # 14. Check cc sp sig if not AugSchemeMPL.verify( header_block.reward_chain_sub_block.proof_of_space.plot_public_key, cc_sp_hash, header_block.reward_chain_sub_block.challenge_chain_sp_signature, ): return None, ValidationError(Err.INVALID_CC_SIGNATURE, "invalid cc sp sig") # 15. Check is_block if genesis_block: if header_block.foliage_sub_block.foliage_block_hash is None: return None, ValidationError(Err.INVALID_IS_BLOCK, "invalid genesis") else: assert prev_sb is not None # Finds the previous block curr = prev_sb while not curr.is_block: curr = sub_blocks.sub_block_record(curr.prev_hash) # The first sub-block to have an sp > the last block's infusion iters, is a block if overflow: our_sp_total_iters: uint128 = uint128(total_iters - ip_iters + sp_iters - expected_sub_slot_iters) else: our_sp_total_iters = uint128(total_iters - ip_iters + sp_iters) if (our_sp_total_iters > curr.total_iters) != ( header_block.foliage_sub_block.foliage_block_hash is not None): return None, ValidationError(Err.INVALID_IS_BLOCK) if (our_sp_total_iters > curr.total_iters) != ( header_block.foliage_sub_block.foliage_block_signature is not None): return None, ValidationError(Err.INVALID_IS_BLOCK) # 16. Check foliage sub block signature by plot key if not AugSchemeMPL.verify( header_block.reward_chain_sub_block.proof_of_space.plot_public_key, header_block.foliage_sub_block.foliage_sub_block_data.get_hash(), header_block.foliage_sub_block.foliage_sub_block_signature, ): return None, ValidationError(Err.INVALID_PLOT_SIGNATURE) # 17. Check foliage block signature by plot key if header_block.foliage_sub_block.foliage_block_hash is not None: if not AugSchemeMPL.verify( header_block.reward_chain_sub_block.proof_of_space. plot_public_key, header_block.foliage_sub_block.foliage_block_hash, header_block.foliage_sub_block.foliage_block_signature, ): return None, ValidationError(Err.INVALID_PLOT_SIGNATURE) # 18. Check unfinished reward chain sub block hash if (header_block.reward_chain_sub_block.get_hash() != header_block.foliage_sub_block.foliage_sub_block_data. unfinished_reward_block_hash): return None, ValidationError(Err.INVALID_URSB_HASH) # 19. Check pool target max height if (header_block.foliage_sub_block.foliage_sub_block_data.pool_target. max_height != 0 and header_block.foliage_sub_block. foliage_sub_block_data.pool_target.max_height < height): return None, ValidationError(Err.OLD_POOL_TARGET) # 20a. Check pre-farm puzzle hashes for genesis sub-block. if genesis_block: if (header_block.foliage_sub_block.foliage_sub_block_data.pool_target. puzzle_hash != constants.GENESIS_PRE_FARM_POOL_PUZZLE_HASH): log.error( f"Pool target {header_block.foliage_sub_block.foliage_sub_block_data.pool_target} hb {header_block}" ) return None, ValidationError(Err.INVALID_PREFARM) if (header_block.foliage_sub_block.foliage_sub_block_data. farmer_reward_puzzle_hash != constants.GENESIS_PRE_FARM_FARMER_PUZZLE_HASH): return None, ValidationError(Err.INVALID_PREFARM) else: # 20b. Check pool target signature. Should not check this for genesis sub-block. if not AugSchemeMPL.verify( header_block.reward_chain_sub_block.proof_of_space. pool_public_key, bytes(header_block.foliage_sub_block.foliage_sub_block_data. pool_target), header_block.foliage_sub_block.foliage_sub_block_data. pool_signature, ): return None, ValidationError(Err.INVALID_POOL_SIGNATURE) # 21. Check extension data if applicable. None for mainnet. # 22. Check if foliage block is present if (header_block.foliage_sub_block.foliage_block_hash is not None) != (header_block.foliage_block is not None): return None, ValidationError(Err.INVALID_FOLIAGE_BLOCK_PRESENCE) if (header_block.foliage_sub_block.foliage_block_signature is not None) != (header_block.foliage_block is not None): return None, ValidationError(Err.INVALID_FOLIAGE_BLOCK_PRESENCE) if header_block.foliage_block is not None: # 23. Check foliage block hash if header_block.foliage_block.get_hash( ) != header_block.foliage_sub_block.foliage_block_hash: return None, ValidationError(Err.INVALID_FOLIAGE_BLOCK_HASH) if genesis_block: # 24a. Check prev block hash for genesis if header_block.foliage_block.prev_block_hash != constants.GENESIS_CHALLENGE: return None, ValidationError(Err.INVALID_PREV_BLOCK_HASH) else: assert prev_sb is not None # 24b. Check prev block hash for non-genesis curr_sb: SubBlockRecord = prev_sb while not curr_sb.is_block: curr_sb = sub_blocks.sub_block_record(curr_sb.prev_hash) if not header_block.foliage_block.prev_block_hash == curr_sb.header_hash: log.error( f"Prev BH: {header_block.foliage_block.prev_block_hash} {curr_sb.header_hash} curr sb: {curr_sb}" ) return None, ValidationError(Err.INVALID_PREV_BLOCK_HASH) # 25. The filter hash in the Foliage Block must be the hash of the filter if check_filter: if header_block.foliage_block.filter_hash != std_hash( header_block.transactions_filter): return None, ValidationError( Err.INVALID_TRANSACTIONS_FILTER_HASH) # 26. The timestamp in Foliage Block must comply with the timestamp rules if prev_sb is not None: last_timestamps: List[uint64] = [] curr_sb = sub_blocks.sub_block_record( header_block.foliage_block.prev_block_hash) assert curr_sb.timestamp is not None while len(last_timestamps) < constants.NUMBER_OF_TIMESTAMPS: last_timestamps.append(curr_sb.timestamp) fetched: Optional[SubBlockRecord] = sub_blocks.try_sub_block( curr_sb.prev_block_hash) if not fetched: break curr_sb = fetched if len(last_timestamps) != constants.NUMBER_OF_TIMESTAMPS: # For blocks 1 to 10, average timestamps of all previous blocks assert curr_sb.height == 0 prev_time: uint64 = uint64( int(sum(last_timestamps) // len(last_timestamps))) if header_block.foliage_block.timestamp <= prev_time: return None, ValidationError(Err.TIMESTAMP_TOO_FAR_IN_PAST) if header_block.foliage_block.timestamp > int( time.time() + constants.MAX_FUTURE_TIME): return None, ValidationError(Err.TIMESTAMP_TOO_FAR_IN_FUTURE) return required_iters, None # Valid unfinished header block
def _get_last_block_in_previous_epoch( constants: ConsensusConstants, sub_blocks: BlockchainInterface, prev_sb: SubBlockRecord, ) -> SubBlockRecord: """ Retrieves the last block (not sub-block) in the previous epoch, which is infused before the last sub-block in the epoch. This will be used for difficulty adjustment. Args: constants: consensus constants being used for this chain sub_blocks: dict from header hash to sub-block of all relevant sub-blocks prev_sb: last-sub-block in the current epoch. prev epoch surpassed prev epoch started epoch sur. epoch started v v v v |.B...B....B. B....B...|......B....B.....B...B.|.B.B.B..|..B...B.B.B...|.B.B.B. B.|........ PREV EPOCH CURR EPOCH NEW EPOCH The sub-blocks selected for the timestamps are the last sub-block which is also a block, and which is infused before the final sub-block in the epoch. Block at height 0 is an exception. # TODO: check edge cases here """ height_in_next_epoch = prev_sb.height + constants.MAX_SUB_SLOT_SUB_BLOCKS + 3 height_epoch_surpass: uint32 = uint32(height_in_next_epoch - (height_in_next_epoch % constants.EPOCH_SUB_BLOCKS)) height_prev_epoch_surpass: uint32 = uint32(height_epoch_surpass - constants.EPOCH_SUB_BLOCKS) if (height_in_next_epoch - height_epoch_surpass) > (3 * constants.MAX_SUB_SLOT_SUB_BLOCKS): raise ValueError( f"Height at {prev_sb.height + 1} should not create a new epoch, it is far past the epoch barrier" ) if height_prev_epoch_surpass == 0: # The genesis block is an edge case, where we measure from the first block in epoch (height 0), as opposed to # the last sub-block in the previous epoch, which would be height -1 return _get_blocks_at_height(sub_blocks, prev_sb, uint32(0))[0] # If the prev slot is the first slot, the iterations start at 0 # We will compute the timestamps of the last block in epoch, as well as the total iterations at infusion first_sb_in_epoch: SubBlockRecord prev_slot_start_iters: uint128 prev_slot_time_start: uint64 fetched_blocks = _get_blocks_at_height( sub_blocks, prev_sb, uint32(height_prev_epoch_surpass - constants.MAX_SUB_SLOT_SUB_BLOCKS - 1), uint32(2 * constants.MAX_SUB_SLOT_SUB_BLOCKS + 1), ) # This is the last sb in the slot at which we surpass the height. The last block in epoch will be before this. fetched_index: int = constants.MAX_SUB_SLOT_SUB_BLOCKS last_sb_in_slot: SubBlockRecord = fetched_blocks[fetched_index] fetched_index += 1 assert last_sb_in_slot.height == height_prev_epoch_surpass - 1 curr_b: SubBlockRecord = fetched_blocks[fetched_index] assert curr_b.height == height_prev_epoch_surpass # Wait until the slot finishes with a challenge chain infusion at start of slot # Note that there are no overflow blocks at the start of new epochs while curr_b.sub_epoch_summary_included is None: last_sb_in_slot = curr_b curr_b = fetched_blocks[fetched_index] fetched_index += 1 # Backtrack to find the last block before the signage point curr_b = sub_blocks.sub_block_record(last_sb_in_slot.prev_hash) while curr_b.total_iters > last_sb_in_slot.sp_total_iters( constants) or not curr_b.is_block: curr_b = sub_blocks.sub_block_record(curr_b.prev_hash) return curr_b
def get_next_difficulty( constants: ConsensusConstants, sub_blocks: BlockchainInterface, prev_header_hash: bytes32, height: uint32, current_difficulty: uint64, deficit: uint8, new_slot: bool, signage_point_total_iters: uint128, skip_epoch_check=False, ) -> uint64: """ Returns the difficulty of the next sub-block that extends onto sub-block. Used to calculate the number of iterations. When changing this, also change the implementation in wallet_state_manager.py. Args: constants: consensus constants being used for this chain sub_blocks: dictionary from header hash to SBR of all included SBR prev_header_hash: header hash of the previous sub-block height: the sub-block height of the sub-block to look at current_difficulty: difficulty at the infusion point of the sub_block at height deficit: deficit of the sub_block at height new_slot: whether or not there is a new slot after height signage_point_total_iters: signage point iters of the sub_block at height skip_epoch_check: don't check correct epoch """ next_height: uint32 = uint32(height + 1) if next_height < (constants.EPOCH_SUB_BLOCKS - constants.MAX_SUB_SLOT_SUB_BLOCKS): # We are in the first epoch return uint64(constants.DIFFICULTY_STARTING) if not sub_blocks.contains_sub_block(prev_header_hash): raise ValueError(f"Header hash {prev_header_hash} not in sub blocks") prev_sb: SubBlockRecord = sub_blocks.sub_block_record(prev_header_hash) # If we are in the same slot as previous sub-block, return same difficulty if not skip_epoch_check: _, can_finish_epoch = can_finish_sub_and_full_epoch( constants, height, deficit, sub_blocks, prev_header_hash, False) if not new_slot or not can_finish_epoch: return current_difficulty last_block_prev: SubBlockRecord = _get_last_block_in_previous_epoch( constants, sub_blocks, prev_sb) # Ensure we get a block for the last block as well, and that it is before the signage point last_block_curr = prev_sb while last_block_curr.total_iters > signage_point_total_iters or not last_block_curr.is_block: last_block_curr = sub_blocks.sub_block_record( last_block_curr.prev_hash) assert last_block_curr.timestamp is not None assert last_block_prev.timestamp is not None actual_epoch_time: uint64 = uint64(last_block_curr.timestamp - last_block_prev.timestamp) old_difficulty = uint64( prev_sb.weight - sub_blocks.sub_block_record(prev_sb.prev_hash).weight) # Terms are rearranged so there is only one division. new_difficulty_precise = ( (last_block_curr.weight - last_block_prev.weight) * constants.SUB_SLOT_TIME_TARGET // (constants.SLOT_SUB_BLOCKS_TARGET * actual_epoch_time)) # Take only DIFFICULTY_SIGNIFICANT_BITS significant bits new_difficulty = uint64( truncate_to_significant_bits(new_difficulty_precise, constants.SIGNIFICANT_BITS)) assert count_significant_bits(new_difficulty) <= constants.SIGNIFICANT_BITS # Only change by a max factor, to prevent attacks, as in greenpaper, and must be at least 1 max_diff = uint64( truncate_to_significant_bits( constants.DIFFICULTY_FACTOR * old_difficulty, constants.SIGNIFICANT_BITS, )) min_diff = uint64( truncate_to_significant_bits( old_difficulty // constants.DIFFICULTY_FACTOR, constants.SIGNIFICANT_BITS, )) if new_difficulty >= old_difficulty: return min(new_difficulty, max_diff) else: return max([uint64(1), new_difficulty, min_diff])
def get_next_sub_slot_iters( constants: ConsensusConstants, sub_blocks: BlockchainInterface, prev_header_hash: bytes32, height: uint32, curr_sub_slot_iters: uint64, deficit: uint8, new_slot: bool, signage_point_total_iters: uint128, skip_epoch_check=False, ) -> uint64: """ Returns the slot iterations required for the next block after the one at height, where new_slot is true iff the next block will be in the next slot. Args: constants: consensus constants being used for this chain sub_blocks: dictionary from header hash to SBR of all included SBR prev_header_hash: header hash of the previous sub-block height: the sub-block height of the sub-block to look at curr_sub_slot_iters: sub-slot iters at the infusion point of the sub_block at height deficit: deficit of the sub_block at height new_slot: whether or not there is a new slot after height signage_point_total_iters: signage point iters of the sub_block at height skip_epoch_check: don't check correct epoch """ next_height: uint32 = uint32(height + 1) if next_height < (constants.EPOCH_SUB_BLOCKS - constants.MAX_SUB_SLOT_SUB_BLOCKS): return uint64(constants.SUB_SLOT_ITERS_STARTING) if not sub_blocks.contains_sub_block(prev_header_hash): raise ValueError(f"Header hash {prev_header_hash} not in sub blocks") prev_sb: SubBlockRecord = sub_blocks.sub_block_record(prev_header_hash) # If we are in the same epoch, return same ssi if not skip_epoch_check: _, can_finish_epoch = can_finish_sub_and_full_epoch( constants, height, deficit, sub_blocks, prev_header_hash, False) if not new_slot or not can_finish_epoch: return curr_sub_slot_iters last_block_prev: SubBlockRecord = _get_last_block_in_previous_epoch( constants, sub_blocks, prev_sb) # Ensure we get a block for the last block as well, and that it is before the signage point last_block_curr = prev_sb while last_block_curr.total_iters > signage_point_total_iters or not last_block_curr.is_block: last_block_curr = sub_blocks.sub_block_record( last_block_curr.prev_hash) assert last_block_curr.timestamp is not None and last_block_prev.timestamp is not None # This is computed as the iterations per second in last epoch, times the target number of seconds per slot new_ssi_precise: uint64 = uint64( constants.SUB_SLOT_TIME_TARGET * (last_block_curr.total_iters - last_block_prev.total_iters) // (last_block_curr.timestamp - last_block_prev.timestamp)) new_ssi = uint64( truncate_to_significant_bits(new_ssi_precise, constants.SIGNIFICANT_BITS)) # Only change by a max factor as a sanity check max_ssi = uint64( truncate_to_significant_bits( constants.DIFFICULTY_FACTOR * last_block_curr.sub_slot_iters, constants.SIGNIFICANT_BITS, )) min_ssi = uint64( truncate_to_significant_bits( last_block_curr.sub_slot_iters // constants.DIFFICULTY_FACTOR, constants.SIGNIFICANT_BITS, )) if new_ssi >= last_block_curr.sub_slot_iters: new_ssi = min(new_ssi, max_ssi) else: new_ssi = uint64(max([constants.NUM_SPS_SUB_SLOT, new_ssi, min_ssi])) new_ssi = uint64( new_ssi - new_ssi % constants.NUM_SPS_SUB_SLOT) # Must divide the sub slot assert count_significant_bits(new_ssi) <= constants.SIGNIFICANT_BITS return new_ssi
def can_finish_sub_and_full_epoch( constants: ConsensusConstants, height: uint32, deficit: uint8, sub_blocks: BlockchainInterface, prev_header_hash: Optional[bytes32], can_finish_soon: bool = False, ) -> Tuple[bool, bool]: """ Returns a bool tuple first bool is true if the next sub-slot after height will form part of a new sub-epoch. Therefore sub_block height is the last sub-block, and height + 1 is in a new sub-epoch. second bool is true if the next sub-slot after height will form part of a new sub-epoch and epoch. Therefore, sub_block height is the last sub-block, and height + 1 is in a new epoch. Warning: This assumes the previous sub-block is not the last sub-block in the sub-epoch (which means this current block does not include a sub epoch summary). TODO: check, simplify, and test code Args: constants: consensus constants being used for this chain height: sub-block height of the (potentially) last sub-block in the sub-epoch deficit: deficit of the sub-block at height sub_blocks: dictionary from header hash to SBR of all included SBR prev_header_hash: prev_header hash of the sub-block at height, assuming not genesis can_finish_soon: this is useful when sending SES to timelords. We might not be able to finish it, but we will soon (within MAX_SUB_SLOT_SUB_BLOCKS) """ if height < constants.SUB_EPOCH_SUB_BLOCKS - constants.MAX_SUB_SLOT_SUB_BLOCKS - 1: return False, False # Used along with "can_finish_soon" future_sb_height = height + constants.MAX_SUB_SLOT_SUB_BLOCKS + 1 assert prev_header_hash is not None # If last slot does not have enough blocks for a new challenge chain infusion, return same difficulty if not can_finish_soon: if deficit > 0: return False, False # Disqualify blocks which are too far past in height # The maximum possible height which includes sub epoch summary if ( height + 1 ) % constants.SUB_EPOCH_SUB_BLOCKS > constants.MAX_SUB_SLOT_SUB_BLOCKS: return False, False check_already_included = (height + 1) % constants.SUB_EPOCH_SUB_BLOCKS > 1 else: # If can_finish_soon=True, we still want to make sure that we will be finishing a sub-epoch soon. # Here we check if a theoretical future block can finish the sub-epoch if ((height + 1) % constants.SUB_EPOCH_SUB_BLOCKS > constants.MAX_SUB_SLOT_SUB_BLOCKS and future_sb_height % constants.SUB_EPOCH_SUB_BLOCKS > constants.MAX_SUB_SLOT_SUB_BLOCKS): return False, False # Don't check already included if we are not at the sub-epoch barrier yet. check_already_included = 1 < ( height + 1 ) % constants.SUB_EPOCH_SUB_BLOCKS <= constants.MAX_SUB_SLOT_SUB_BLOCKS # For sub-blocks which equal 0 or 1, we assume that the sub-epoch has not been finished yet if check_already_included: already_included_ses = False curr: SubBlockRecord = sub_blocks.sub_block_record(prev_header_hash) while curr.height % constants.SUB_EPOCH_SUB_BLOCKS > 0: if curr.sub_epoch_summary_included is not None: already_included_ses = True break curr = sub_blocks.sub_block_record(curr.prev_hash) if already_included_ses or (curr.sub_epoch_summary_included is not None): return False, False # For checking new epoch, make sure the epoch sub blocks are aligned if not can_finish_soon: if (height + 1 ) % constants.EPOCH_SUB_BLOCKS > constants.MAX_SUB_SLOT_SUB_BLOCKS: return True, False else: if ((height + 1) % constants.EPOCH_SUB_BLOCKS > constants.MAX_SUB_SLOT_SUB_BLOCKS and future_sb_height % constants.EPOCH_SUB_BLOCKS > constants.MAX_SUB_SLOT_SUB_BLOCKS): return True, False return True, True
def block_to_sub_block_record( constants: ConsensusConstants, sub_blocks: BlockchainInterface, required_iters: uint64, full_block: Optional[Union[FullBlock, HeaderBlock]], header_block: Optional[HeaderBlock], ): if full_block is None: assert header_block is not None block: Union[HeaderBlock, FullBlock] = header_block else: block = full_block if block.height == 0: prev_sb: Optional[SubBlockRecord] = None sub_slot_iters: uint64 = uint64(constants.SUB_SLOT_ITERS_STARTING) else: prev_sb = sub_blocks.sub_block_record(block.prev_header_hash) assert prev_sb is not None sub_slot_iters = get_next_sub_slot_iters( constants, sub_blocks, prev_sb.prev_hash, prev_sb.height, prev_sb.sub_slot_iters, prev_sb.deficit, len(block.finished_sub_slots) > 0, prev_sb.sp_total_iters(constants), ) overflow = is_overflow_sub_block(constants, block.reward_chain_sub_block.signage_point_index) deficit = calculate_deficit( constants, block.height, prev_sb, overflow, len(block.finished_sub_slots), ) prev_block_hash = block.foliage_block.prev_block_hash if block.foliage_block is not None else None timestamp = block.foliage_block.timestamp if block.foliage_block is not None else None fees = block.transactions_info.fees if block.transactions_info is not None else None reward_claims_incorporated = ( block.transactions_info.reward_claims_incorporated if block.transactions_info is not None else None ) if len(block.finished_sub_slots) > 0: finished_challenge_slot_hashes: Optional[List[bytes32]] = [ sub_slot.challenge_chain.get_hash() for sub_slot in block.finished_sub_slots ] finished_reward_slot_hashes: Optional[List[bytes32]] = [ sub_slot.reward_chain.get_hash() for sub_slot in block.finished_sub_slots ] finished_infused_challenge_slot_hashes: Optional[List[bytes32]] = [ sub_slot.infused_challenge_chain.get_hash() for sub_slot in block.finished_sub_slots if sub_slot.infused_challenge_chain is not None ] elif block.height == 0: finished_challenge_slot_hashes = [constants.GENESIS_CHALLENGE] finished_reward_slot_hashes = [constants.GENESIS_CHALLENGE] finished_infused_challenge_slot_hashes = None else: finished_challenge_slot_hashes = None finished_reward_slot_hashes = None finished_infused_challenge_slot_hashes = None found_ses_hash: Optional[bytes32] = None ses: Optional[SubEpochSummary] = None if len(block.finished_sub_slots) > 0: for sub_slot in block.finished_sub_slots: if sub_slot.challenge_chain.subepoch_summary_hash is not None: found_ses_hash = sub_slot.challenge_chain.subepoch_summary_hash if found_ses_hash: assert prev_sb is not None assert len(block.finished_sub_slots) > 0 ses = make_sub_epoch_summary( constants, sub_blocks, block.height, sub_blocks.sub_block_record(prev_sb.prev_hash), block.finished_sub_slots[0].challenge_chain.new_difficulty, block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters, ) assert ses.get_hash() == found_ses_hash cbi = ChallengeBlockInfo( block.reward_chain_sub_block.proof_of_space, block.reward_chain_sub_block.challenge_chain_sp_vdf, block.reward_chain_sub_block.challenge_chain_sp_signature, block.reward_chain_sub_block.challenge_chain_ip_vdf, ) if block.reward_chain_sub_block.infused_challenge_chain_ip_vdf is not None: icc_output: Optional[ClassgroupElement] = block.reward_chain_sub_block.infused_challenge_chain_ip_vdf.output else: icc_output = None prev_transaction_block_height = uint32(0) curr: Optional[SubBlockRecord] = sub_blocks.try_sub_block(block.prev_header_hash) while curr is not None and not curr.is_block: curr = sub_blocks.try_sub_block(curr.prev_hash) if curr is not None and curr.is_block: prev_transaction_block_height = curr.height return SubBlockRecord( block.header_hash, block.prev_header_hash, block.height, block.weight, block.total_iters, block.reward_chain_sub_block.signage_point_index, block.reward_chain_sub_block.challenge_chain_ip_vdf.output, icc_output, block.reward_chain_sub_block.get_hash(), cbi.get_hash(), sub_slot_iters, block.foliage_sub_block.foliage_sub_block_data.pool_target.puzzle_hash, block.foliage_sub_block.foliage_sub_block_data.farmer_reward_puzzle_hash, required_iters, deficit, overflow, prev_transaction_block_height, timestamp, prev_block_hash, fees, reward_claims_incorporated, finished_challenge_slot_hashes, finished_infused_challenge_slot_hashes, finished_reward_slot_hashes, ses, )
async def pre_validate_blocks_multiprocessing( constants: ConsensusConstants, constants_json: Dict, sub_blocks: BlockchainInterface, blocks: Sequence[Union[FullBlock, HeaderBlock]], pool: ProcessPoolExecutor, ) -> Optional[List[PreValidationResult]]: """ This method must be called under the blockchain lock If all the full blocks pass pre-validation, (only validates header), returns the list of required iters. if any validation issue occurs, returns False. Args: constants_json: pool: constants: sub_blocks: blocks: list of full blocks to validate (must be connected to current chain) """ batch_size = 4 prev_sb: Optional[SubBlockRecord] = None # Collects all the recent sub-blocks (up to the previous sub-epoch) recent_sub_blocks: Dict[bytes32, SubBlockRecord] = {} recent_sub_blocks_compressed: Dict[bytes32, SubBlockRecord] = {} num_sub_slots_found = 0 num_blocks_seen = 0 if blocks[0].height > 0: if not sub_blocks.contains_sub_block(blocks[0].prev_header_hash): return [ PreValidationResult(uint16(Err.INVALID_PREV_BLOCK_HASH.value), None, None) ] curr = sub_blocks.sub_block_record(blocks[0].prev_header_hash) num_sub_slots_to_look_for = 3 if curr.overflow else 2 while (curr.sub_epoch_summary_included is None or num_blocks_seen < constants.NUMBER_OF_TIMESTAMPS or num_sub_slots_found < num_sub_slots_to_look_for ) and curr.height > 0: if num_blocks_seen < constants.NUMBER_OF_TIMESTAMPS or num_sub_slots_found < num_sub_slots_to_look_for: recent_sub_blocks_compressed[curr.header_hash] = curr if curr.first_in_sub_slot: assert curr.finished_challenge_slot_hashes is not None num_sub_slots_found += len(curr.finished_challenge_slot_hashes) recent_sub_blocks[curr.header_hash] = curr if curr.is_block: num_blocks_seen += 1 curr = sub_blocks.sub_block_record(curr.prev_hash) recent_sub_blocks[curr.header_hash] = curr recent_sub_blocks_compressed[curr.header_hash] = curr sub_block_was_present = [] for block in blocks: sub_block_was_present.append( sub_blocks.contains_sub_block(block.header_hash)) diff_ssis: List[Tuple[uint64, uint64]] = [] for sub_block in blocks: if sub_block.height != 0 and prev_sb is None: prev_sb = sub_blocks.sub_block_record(sub_block.prev_header_hash) sub_slot_iters, difficulty = get_sub_slot_iters_and_difficulty( constants, sub_block, prev_sb, sub_blocks) if sub_block.reward_chain_sub_block.signage_point_index >= constants.NUM_SPS_SUB_SLOT: log.warning(f"Sub block: {sub_block.reward_chain_sub_block}") overflow = is_overflow_sub_block( constants, sub_block.reward_chain_sub_block.signage_point_index) challenge = get_block_challenge( constants, sub_block, BlockCache(recent_sub_blocks), prev_sb is None, overflow, False, ) if sub_block.reward_chain_sub_block.challenge_chain_sp_vdf is None: cc_sp_hash: bytes32 = challenge else: cc_sp_hash = sub_block.reward_chain_sub_block.challenge_chain_sp_vdf.output.get_hash( ) q_str: Optional[ bytes32] = sub_block.reward_chain_sub_block.proof_of_space.verify_and_get_quality_string( constants, challenge, cc_sp_hash) if q_str is None: for i, block_i in enumerate(blocks): if not sub_block_was_present[ i] and sub_blocks.contains_sub_block( block_i.header_hash): sub_blocks.remove_sub_block(block_i.header_hash) return None required_iters: uint64 = calculate_iterations_quality( q_str, sub_block.reward_chain_sub_block.proof_of_space.size, difficulty, cc_sp_hash, ) sub_block_rec = block_to_sub_block_record( constants, sub_blocks, required_iters, sub_block, None, ) recent_sub_blocks[sub_block_rec.header_hash] = sub_block_rec recent_sub_blocks_compressed[sub_block_rec.header_hash] = sub_block_rec sub_blocks.add_sub_block( sub_block_rec) # Temporarily add sub block to dict prev_sb = sub_block_rec diff_ssis.append((difficulty, sub_slot_iters)) for i, block in enumerate(blocks): if not sub_block_was_present[i]: sub_blocks.remove_sub_block(block.header_hash) recent_sb_compressed_pickled = { bytes(k): bytes(v) for k, v in recent_sub_blocks_compressed.items() } futures = [] # Pool of workers to validate blocks concurrently for i in range(0, len(blocks), batch_size): end_i = min(i + batch_size, len(blocks)) blocks_to_validate = blocks[i:end_i] if any([ len(block.finished_sub_slots) > 0 for block in blocks_to_validate ]): final_pickled = { bytes(k): bytes(v) for k, v in recent_sub_blocks.items() } else: final_pickled = recent_sb_compressed_pickled hb_pickled: List[bytes] = [] generators: List[Optional[bytes]] = [] for block in blocks_to_validate: if isinstance(block, FullBlock): hb_pickled.append(bytes(block.get_block_header())) generators.append( bytes(block.transactions_generator) if block. transactions_generator is not None else None) else: hb_pickled.append(bytes(block)) generators.append(None) futures.append(asyncio.get_running_loop().run_in_executor( pool, batch_pre_validate_sub_blocks, constants_json, final_pickled, hb_pickled, generators, True, [diff_ssis[j][0] for j in range(i, end_i)], [diff_ssis[j][1] for j in range(i, end_i)], )) # Collect all results into one flat list return [ PreValidationResult.from_bytes(result) for batch_result in (await asyncio.gather(*futures)) for result in batch_result ]
def validate_finished_header_block( constants: ConsensusConstants, sub_blocks: BlockchainInterface, header_block: HeaderBlock, check_filter: bool, expected_difficulty: uint64, expected_sub_slot_iters: uint64, ) -> Tuple[Optional[uint64], Optional[ValidationError]]: """ Fully validates the header of a sub-block. A header block is the same as a full block, but without transactions and transaction info. Returns (required_iters, error). """ unfinished_header_block = UnfinishedHeaderBlock( header_block.finished_sub_slots, header_block.reward_chain_sub_block.get_unfinished(), header_block.challenge_chain_sp_proof, header_block.reward_chain_sp_proof, header_block.foliage_sub_block, header_block.foliage_block, header_block.transactions_filter, ) required_iters, validate_unfinished_err = validate_unfinished_header_block( constants, sub_blocks, unfinished_header_block, check_filter, expected_difficulty, expected_sub_slot_iters, False, ) genesis_block = False if validate_unfinished_err is not None: return None, validate_unfinished_err assert required_iters is not None if header_block.height == 0: prev_sb: Optional[SubBlockRecord] = None genesis_block = True else: prev_sb = sub_blocks.sub_block_record(header_block.prev_header_hash) new_sub_slot: bool = len(header_block.finished_sub_slots) > 0 ip_iters: uint64 = calculate_ip_iters( constants, expected_sub_slot_iters, header_block.reward_chain_sub_block.signage_point_index, required_iters, ) if not genesis_block: assert prev_sb is not None # 27. Check sub-block height if header_block.height != prev_sb.height + 1: return None, ValidationError(Err.INVALID_HEIGHT) # 28. Check weight if header_block.weight != prev_sb.weight + expected_difficulty: log.error( f"INVALID WEIGHT: {header_block} {prev_sb} {expected_difficulty}" ) return None, ValidationError(Err.INVALID_WEIGHT) else: if header_block.height != uint32(0): return None, ValidationError(Err.INVALID_HEIGHT) if header_block.weight != constants.DIFFICULTY_STARTING: return None, ValidationError(Err.INVALID_WEIGHT) # RC vdf challenge is taken from more recent of (slot start, prev_block) if genesis_block: cc_vdf_output = ClassgroupElement.get_default_element() ip_vdf_iters = ip_iters if new_sub_slot: rc_vdf_challenge = header_block.finished_sub_slots[ -1].reward_chain.get_hash() else: rc_vdf_challenge = constants.GENESIS_CHALLENGE else: assert prev_sb is not None if new_sub_slot: # slot start is more recent rc_vdf_challenge = header_block.finished_sub_slots[ -1].reward_chain.get_hash() ip_vdf_iters = ip_iters cc_vdf_output = ClassgroupElement.get_default_element() else: # Prev sb is more recent rc_vdf_challenge = prev_sb.reward_infusion_new_challenge ip_vdf_iters = uint64( header_block.reward_chain_sub_block.total_iters - prev_sb.total_iters) cc_vdf_output = prev_sb.challenge_vdf_output # 29. Check challenge chain infusion point VDF if new_sub_slot: cc_vdf_challenge = header_block.finished_sub_slots[ -1].challenge_chain.get_hash() else: # Not first sub-block in slot if genesis_block: # genesis block cc_vdf_challenge = constants.GENESIS_CHALLENGE else: assert prev_sb is not None # Not genesis block, go back to first sub-block in slot curr = prev_sb while curr.finished_challenge_slot_hashes is None: curr = sub_blocks.sub_block_record(curr.prev_hash) cc_vdf_challenge = curr.finished_challenge_slot_hashes[-1] cc_target_vdf_info = VDFInfo( cc_vdf_challenge, ip_vdf_iters, header_block.reward_chain_sub_block.challenge_chain_ip_vdf.output, ) if header_block.reward_chain_sub_block.challenge_chain_ip_vdf != dataclasses.replace( cc_target_vdf_info, number_of_iterations=ip_iters, ): expected = dataclasses.replace( cc_target_vdf_info, number_of_iterations=ip_iters, ) log.error( f"{header_block.reward_chain_sub_block.challenge_chain_ip_vdf }. expected {expected}" ) log.error(f"Block: {header_block}") return None, ValidationError(Err.INVALID_CC_IP_VDF) if not header_block.challenge_chain_ip_proof.is_valid( constants, cc_vdf_output, cc_target_vdf_info, None, ): log.error(f"Did not validate, output {cc_vdf_output}") log.error(f"Block: {header_block}") return None, ValidationError(Err.INVALID_CC_IP_VDF) # 30. Check reward chain infusion point VDF rc_target_vdf_info = VDFInfo( rc_vdf_challenge, ip_vdf_iters, header_block.reward_chain_sub_block.reward_chain_ip_vdf.output, ) if not header_block.reward_chain_ip_proof.is_valid( constants, ClassgroupElement.get_default_element(), header_block.reward_chain_sub_block.reward_chain_ip_vdf, rc_target_vdf_info, ): return None, ValidationError(Err.INVALID_RC_IP_VDF) # 31. Check infused challenge chain infusion point VDF if not genesis_block: overflow = is_overflow_sub_block( constants, header_block.reward_chain_sub_block.signage_point_index) deficit = calculate_deficit( constants, header_block.height, prev_sb, overflow, len(header_block.finished_sub_slots), ) if header_block.reward_chain_sub_block.infused_challenge_chain_ip_vdf is None: # If we don't have an ICC chain, deficit must be 4 or 5 if deficit < constants.MIN_SUB_BLOCKS_PER_CHALLENGE_BLOCK - 1: return None, ValidationError(Err.INVALID_ICC_VDF) else: assert header_block.infused_challenge_chain_ip_proof is not None # If we have an ICC chain, deficit must be 0, 1, 2 or 3 if deficit >= constants.MIN_SUB_BLOCKS_PER_CHALLENGE_BLOCK - 1: return ( None, ValidationError( Err.INVALID_ICC_VDF, f"icc vdf and deficit is bigger or equal to {constants.MIN_SUB_BLOCKS_PER_CHALLENGE_BLOCK - 1}", ), ) if new_sub_slot: last_ss = header_block.finished_sub_slots[-1] assert last_ss.infused_challenge_chain is not None icc_vdf_challenge: bytes32 = last_ss.infused_challenge_chain.get_hash( ) icc_vdf_input = ClassgroupElement.get_default_element() else: assert prev_sb is not None if prev_sb.is_challenge_sub_block(constants): icc_vdf_input = ClassgroupElement.get_default_element() else: icc_vdf_input = prev_sb.infused_challenge_vdf_output curr = prev_sb while curr.finished_infused_challenge_slot_hashes is None and not curr.is_challenge_sub_block( constants): curr = sub_blocks.sub_block_record(curr.prev_hash) if curr.is_challenge_sub_block(constants): icc_vdf_challenge = curr.challenge_block_info_hash else: assert curr.finished_infused_challenge_slot_hashes is not None icc_vdf_challenge = curr.finished_infused_challenge_slot_hashes[ -1] icc_target_vdf_info = VDFInfo( icc_vdf_challenge, ip_vdf_iters, header_block.reward_chain_sub_block. infused_challenge_chain_ip_vdf.output, ) if not header_block.infused_challenge_chain_ip_proof.is_valid( constants, icc_vdf_input, header_block.reward_chain_sub_block. infused_challenge_chain_ip_vdf, icc_target_vdf_info, ): return None, ValidationError(Err.INVALID_ICC_VDF, "invalid icc proof") else: if header_block.infused_challenge_chain_ip_proof is not None: return None, ValidationError(Err.INVALID_ICC_VDF) # 32. Check reward block hash if header_block.foliage_sub_block.reward_block_hash != header_block.reward_chain_sub_block.get_hash( ): return None, ValidationError(Err.INVALID_REWARD_BLOCK_HASH) # 33. Check reward block is_block if (header_block.foliage_sub_block.foliage_block_hash is not None) != header_block.reward_chain_sub_block.is_block: return None, ValidationError(Err.INVALID_FOLIAGE_BLOCK_PRESENCE) return required_iters, None
def create_unfinished_block( constants: ConsensusConstants, sub_slot_start_total_iters: uint128, sub_slot_iters: uint64, signage_point_index: uint8, sp_iters: uint64, ip_iters: uint64, proof_of_space: ProofOfSpace, slot_cc_challenge: bytes32, farmer_reward_puzzle_hash: bytes32, pool_target: PoolTarget, get_plot_signature: Callable[[bytes32, G1Element], G2Element], get_pool_signature: Callable[[PoolTarget, G1Element], G2Element], signage_point: SignagePoint, timestamp: uint64, sub_blocks: BlockchainInterface, seed: bytes32 = b"", spend_bundle: Optional[SpendBundle] = None, prev_sub_block: Optional[SubBlockRecord] = None, finished_sub_slots_input: List[EndOfSubSlotBundle] = None, ) -> UnfinishedBlock: """ Creates a new unfinished block using all the information available at the signage point. This will have to be modified using information from the infusion point. Args: constants: consensus constants being used for this chain sub_slot_start_total_iters: the starting sub-slot iters at the signage point sub-slot sub_slot_iters: sub-slot-iters at the infusion point epoch signage_point_index: signage point index of the sub-block to create sp_iters: sp_iters of the sub-block to create ip_iters: ip_iters of the sub-block to create proof_of_space: proof of space of the sub-block to create slot_cc_challenge: challenge hash at the sp sub-slot farmer_reward_puzzle_hash: where to pay out farmer rewards pool_target: where to pay out pool rewards get_plot_signature: function that returns signature corresponding to plot public key get_pool_signature: function that returns signature corresponding to pool public key signage_point: signage point information (VDFs) timestamp: timestamp to add to the foliage block, if created seed: seed to randomize chain spend_bundle: transactions to add to the foliage block, if created prev_sub_block: previous sub-block (already in chain) from the signage point sub_blocks: dictionary from header hash to SBR of all included SBR finished_sub_slots_input: finished_sub_slots at the signage point Returns: """ if finished_sub_slots_input is None: finished_sub_slots: List[EndOfSubSlotBundle] = [] else: finished_sub_slots = finished_sub_slots_input.copy() overflow: bool = sp_iters > ip_iters total_iters_sp: uint128 = uint128(sub_slot_start_total_iters + sp_iters) is_genesis: bool = prev_sub_block is None new_sub_slot: bool = len(finished_sub_slots) > 0 cc_sp_hash: Optional[bytes32] = slot_cc_challenge # Only enters this if statement if we are in testing mode (making VDF proofs here) if signage_point.cc_vdf is not None: assert signage_point.rc_vdf is not None cc_sp_hash = signage_point.cc_vdf.output.get_hash() rc_sp_hash = signage_point.rc_vdf.output.get_hash() else: if new_sub_slot: rc_sp_hash = finished_sub_slots[-1].reward_chain.get_hash() else: if is_genesis: rc_sp_hash = constants.GENESIS_CHALLENGE else: assert prev_sub_block is not None assert sub_blocks is not None curr = prev_sub_block while not curr.first_in_sub_slot: curr = sub_blocks.sub_block_record(curr.prev_hash) assert curr.finished_reward_slot_hashes is not None rc_sp_hash = curr.finished_reward_slot_hashes[-1] signage_point = SignagePoint(None, None, None, None) cc_sp_signature: Optional[G2Element] = get_plot_signature( cc_sp_hash, proof_of_space.plot_public_key) rc_sp_signature: Optional[G2Element] = get_plot_signature( rc_sp_hash, proof_of_space.plot_public_key) assert cc_sp_signature is not None assert rc_sp_signature is not None assert blspy.AugSchemeMPL.verify(proof_of_space.plot_public_key, cc_sp_hash, cc_sp_signature) total_iters = uint128(sub_slot_start_total_iters + ip_iters + (sub_slot_iters if overflow else 0)) rc_sub_block = RewardChainSubBlockUnfinished( total_iters, signage_point_index, slot_cc_challenge, proof_of_space, signage_point.cc_vdf, cc_sp_signature, signage_point.rc_vdf, rc_sp_signature, ) ( foliage_sub_block, foliage_block, transactions_info, solution_program, ) = create_foliage( constants, rc_sub_block, spend_bundle, prev_sub_block, sub_blocks, total_iters_sp, timestamp, farmer_reward_puzzle_hash, pool_target, get_plot_signature, get_pool_signature, seed, ) return UnfinishedBlock( finished_sub_slots, rc_sub_block, signage_point.cc_proof, signage_point.rc_proof, foliage_sub_block, foliage_block, transactions_info, solution_program, )