block - [mainnet]

public(friend) fun initialize(aptos_framework: &signer, epoch_interval_microsecs: u64) {
    system_addresses::assert_aptos_framework(aptos_framework);
    assert!(epoch_interval_microsecs > 0, error::invalid_argument(EZERO_EPOCH_INTERVAL));

    move_to<CommitHistory>(aptos_framework, CommitHistory {
        max_capacity: 2000,
        next_idx: 0,
        table: table_with_length::new(),
    });

    move_to<BlockResource>(
        aptos_framework,
        BlockResource {
            height: 0,
            epoch_interval: epoch_interval_microsecs,
            new_block_events: account::new_event_handle<NewBlockEvent>(aptos_framework),
            update_epoch_interval_events: account::new_event_handle<UpdateEpochIntervalEvent>(aptos_framework),
        }
    );
}

public fun initialize_commit_history(fx: &signer, max_capacity: u32) {
    assert!(max_capacity > 0, error::invalid_argument(EZERO_MAX_CAPACITY));
    move_to<CommitHistory>(fx, CommitHistory {
        max_capacity,
        next_idx: 0,
        table: table_with_length::new(),
    });
}

public fun update_epoch_interval_microsecs(
    aptos_framework: &signer,
    new_epoch_interval: u64,
) acquires BlockResource {
    system_addresses::assert_aptos_framework(aptos_framework);
    assert!(new_epoch_interval > 0, error::invalid_argument(EZERO_EPOCH_INTERVAL));

    let block_resource = borrow_global_mut<BlockResource>(@aptos_framework);
    let old_epoch_interval = block_resource.epoch_interval;
    block_resource.epoch_interval = new_epoch_interval;

    if (std::features::module_event_migration_enabled()) {
        event::emit(
            UpdateEpochInterval { old_epoch_interval, new_epoch_interval },
        );
    } else {
        event::emit_event<UpdateEpochIntervalEvent>(
            &mut block_resource.update_epoch_interval_events,
            UpdateEpochIntervalEvent { old_epoch_interval, new_epoch_interval },
        );
    };
}

public fun get_epoch_interval_secs(): u64 acquires BlockResource {
    borrow_global<BlockResource>(@aptos_framework).epoch_interval / 1000000
}

fun block_prologue_common(
    vm: &signer,
    hash: address,
    epoch: u64,
    round: u64,
    proposer: address,
    failed_proposer_indices: vector<u64>,
    previous_block_votes_bitvec: vector<u8>,
    timestamp: u64
): u64 acquires BlockResource, CommitHistory {
    // Operational constraint: can only be invoked by the VM.
    system_addresses::assert_vm(vm);

    // Blocks can only be produced by a valid proposer or by the VM itself for Nil blocks (no user txs).
    assert!(
        proposer == @vm_reserved || stake::is_current_epoch_validator(proposer),
        error::permission_denied(EINVALID_PROPOSER),
    );

    let proposer_index = option::none();
    if (proposer != @vm_reserved) {
        proposer_index = option::some(stake::get_validator_index(proposer));
    };

    let block_metadata_ref = borrow_global_mut<BlockResource>(@aptos_framework);
    block_metadata_ref.height = event::counter(&block_metadata_ref.new_block_events);

    let new_block_event = NewBlockEvent {
        hash,
        epoch,
        round,
        height: block_metadata_ref.height,
        previous_block_votes_bitvec,
        proposer,
        failed_proposer_indices,
        time_microseconds: timestamp,
    };
    emit_new_block_event(vm, &mut block_metadata_ref.new_block_events, new_block_event);

    // Performance scores have to be updated before the epoch transition as the transaction that triggers the
    // transition is the last block in the previous epoch.
    stake::update_performance_statistics(proposer_index, failed_proposer_indices);
    state_storage::on_new_block(reconfiguration::current_epoch());

    block_metadata_ref.epoch_interval
}

fun block_prologue(
    vm: signer,
    hash: address,
    epoch: u64,
    round: u64,
    proposer: address,
    failed_proposer_indices: vector<u64>,
    previous_block_votes_bitvec: vector<u8>,
    timestamp: u64
) acquires BlockResource, CommitHistory {
    let epoch_interval = block_prologue_common(&vm, hash, epoch, round, proposer, failed_proposer_indices, previous_block_votes_bitvec, timestamp);
    randomness::on_new_block(&vm, epoch, round, option::none());
    if (timestamp - reconfiguration::last_reconfiguration_time() >= epoch_interval) {
        reconfiguration::reconfigure();
    };
}

fun block_prologue_ext(
    vm: signer,
    hash: address,
    epoch: u64,
    round: u64,
    proposer: address,
    failed_proposer_indices: vector<u64>,
    previous_block_votes_bitvec: vector<u8>,
    timestamp: u64,
    randomness_seed: Option<vector<u8>>,
) acquires BlockResource, CommitHistory {
    let epoch_interval = block_prologue_common(
        &vm,
        hash,
        epoch,
        round,
        proposer,
        failed_proposer_indices,
        previous_block_votes_bitvec,
        timestamp
    );
    randomness::on_new_block(&vm, epoch, round, randomness_seed);

    if (timestamp - reconfiguration::last_reconfiguration_time() >= epoch_interval) {
        reconfiguration_with_dkg::try_start();
    };
}

public fun get_current_block_height(): u64 acquires BlockResource {
    borrow_global<BlockResource>(@aptos_framework).height
}

fun emit_new_block_event(
    vm: &signer,
    event_handle: &mut EventHandle<NewBlockEvent>,
    new_block_event: NewBlockEvent,
) acquires CommitHistory {
    if (exists<CommitHistory>(@aptos_framework)) {
        let commit_history_ref = borrow_global_mut<CommitHistory>(@aptos_framework);
        let idx = commit_history_ref.next_idx;
        if (table_with_length::contains(&commit_history_ref.table, idx)) {
            table_with_length::remove(&mut commit_history_ref.table, idx);
        };
        table_with_length::add(&mut commit_history_ref.table, idx, copy new_block_event);
        spec {
            assume idx + 1 <= MAX_U32;
        };
        commit_history_ref.next_idx = (idx + 1) % commit_history_ref.max_capacity;
    };
    timestamp::update_global_time(vm, new_block_event.proposer, new_block_event.time_microseconds);
    assert!(
        event::counter(event_handle) == new_block_event.height,
        error::invalid_argument(ENUM_NEW_BLOCK_EVENTS_DOES_NOT_MATCH_BLOCK_HEIGHT),
    );
    event::emit_event<NewBlockEvent>(event_handle, new_block_event);
}

fun emit_genesis_block_event(vm: signer) acquires BlockResource, CommitHistory {
    let block_metadata_ref = borrow_global_mut<BlockResource>(@aptos_framework);
    let genesis_id = @0x0;
    emit_new_block_event(
        &vm,
        &mut block_metadata_ref.new_block_events,
        NewBlockEvent {
            hash: genesis_id,
            epoch: 0,
            round: 0,
            height: 0,
            previous_block_votes_bitvec: vector::empty(),
            proposer: @vm_reserved,
            failed_proposer_indices: vector::empty(),
            time_microseconds: 0,
        },
    );
}

public fun emit_writeset_block_event(vm_signer: &signer, fake_block_hash: address) acquires BlockResource, CommitHistory {
    system_addresses::assert_vm(vm_signer);
    let block_metadata_ref = borrow_global_mut<BlockResource>(@aptos_framework);
    block_metadata_ref.height = event::counter(&block_metadata_ref.new_block_events);

    emit_new_block_event(
        vm_signer,
        &mut block_metadata_ref.new_block_events,
        NewBlockEvent {
            hash: fake_block_hash,
            epoch: reconfiguration::current_epoch(),
            round: MAX_U64,
            height: block_metadata_ref.height,
            previous_block_votes_bitvec: vector::empty(),
            proposer: @vm_reserved,
            failed_proposer_indices: vector::empty(),
            time_microseconds: timestamp::now_microseconds(),
        },
    );
}