Method apply_blocks

header-chain/src/header_chain.rs:190–283

(&mut self, block_headers: Vec<CircuitBlockHeader>)

    }

    pub fn apply_blocks(&mut self, block_headers: Vec<CircuitBlockHeader>) {
        let mut current_target_bytes = if IS_REGTEST {
            NETWORK_CONSTANTS.max_target.to_be_bytes()
        } else {
            bits_to_target(self.current_target_bits)
        };
        let mut current_work: U256 = U256::from_be_bytes(self.total_work);

        let mut last_block_time = if IS_TESTNET4 {
            if self.block_height == u32::MAX {
                0
            } else {
                self.prev_11_timestamps[self.block_height as usize % 11]
            }
        } else {
            0
        };

        for block_header in block_headers {
            self.block_height = self.block_height.wrapping_add(1);

            let (target_to_use, expected_bits, work_to_add) = if IS_TESTNET4 {
                if block_header.time > last_block_time + 1200 {
                    // If the block is an epoch block, then it still has to have the real target.
                    if self.block_height % BLOCKS_PER_EPOCH == 0 {
                        (
                            current_target_bytes,
                            self.current_target_bits,
                            calculate_work(&current_target_bytes),
                        )
                    } else {
                        (
                            NETWORK_CONSTANTS.max_target_bytes,
                            NETWORK_CONSTANTS.max_bits,
                            MINIMUM_WORK_TESTNET,
                        )
                    }
                } else {
                    (
                        current_target_bytes,
                        self.current_target_bits,
                        calculate_work(&current_target_bytes),
                    )
                }
            } else {
                (
                    current_target_bytes,
                    self.current_target_bits,
                    calculate_work(&current_target_bytes),
                )
            };

            let new_block_hash = block_header.compute_block_hash();

            assert_eq!(block_header.prev_block_hash, self.best_block_hash);

            if IS_REGTEST {
                assert_eq!(block_header.bits, NETWORK_CONSTANTS.max_bits);