Method finalize_block

fendermint/app/src/app.rs:923–1058

The transaction execution step of the application. Combines what used to be `BeginBlock`, `DeliverTx`, and `EndBlock`.

(
        &self,
        request: request::FinalizeBlock,
    )

    }
    /// The transaction execution step of the application. Combines what used to be `BeginBlock`, `DeliverTx`, and `EndBlock`.
    async fn finalize_block(
        &self,
        request: request::FinalizeBlock,
    ) -> AbciResult<response::FinalizeBlock> {
        tracing::debug!(
            height = request.height.value(),
            timestamp = request.time.unix_timestamp(),
            hash = request.hash.to_string(),
            "finalize block"
        );

        // BeginBlock
        let block_height = request.height.into();
        let block_hash = match request.hash {
            tendermint::Hash::Sha256(h) => h,
            tendermint::Hash::None => return Err(anyhow!("empty block hash").into()),
        };

        if self.halt_height != 0 && block_height == self.halt_height {
            tracing::info!(
                height = block_height,
                "Stopping node due to reaching halt height"
            );
            std::process::exit(AppExitCode::Halt as i32);
        }

        let db = self.state_store_clone();
        let state = self.committed_state()?;
        let mut state_params = state.state_params.clone();

        state_params.timestamp = to_timestamp(request.time);

        let state = FvmExecState::new(db, self.multi_engine.as_ref(), block_height, state_params)
            .context("error creating new state")?
            .with_block_hash(block_hash)
            .with_validator_id(request.proposer_address);

        tracing::debug!("initialized exec state");

        self.put_exec_state(state).await;

        let ret = self
            .modify_exec_state(|s| self.interpreter.begin(s))
            .await
            .context("begin failed")?;

        // [Deliver Tx]
        let mut tx_results = Vec::new();
        for tx in request.txs {
            let msg = tx.to_vec();
            let (result, block_hash) = self
                .modify_exec_state(|s| async {
                    let ((env, state), res) = self.interpreter.deliver(s, msg).await?;
                    let block_hash = state.block_hash();
                    Ok(((env, state), (res, block_hash)))
                })
                .await
                .context("deliver failed")?;