Method execute_payload

crates/execution/rpc/src/debug.rs:189–240

(
        &self,
        parent_block_hash: B256,
        attributes: Attrs::RpcPayloadAttributes,
    )

        + 'static,
{
    async fn execute_payload(
        &self,
        parent_block_hash: B256,
        attributes: Attrs::RpcPayloadAttributes,
    ) -> RpcResult<ExecutionWitness> {
        DebugApiExtMetrics::record_operation_async(DebugApis::DebugExecutePayload, async {
            let _permit = self.inner.semaphore.acquire().await;

            let parent_header = self.parent_header(parent_block_hash).to_rpc_result()?;

            let (tx, rx) = oneshot::channel();
            let this = Arc::clone(&self.inner);
            self.inner.task_spawner.spawn_blocking_task(async move {
                let result = async {
                    let parent_hash = parent_header.hash();
                    let attributes = Attrs::try_new(parent_hash, attributes, 3)
                        .map_err(PayloadBuilderError::other)?;
                    let payload_id = attributes.payload_job_id();

                    let config =
                        PayloadConfig::new(Arc::new(parent_header), attributes, payload_id);
                    let ctx = BasePayloadBuilderCtx {
                        evm_config: this.evm_config.clone(),
                        chain_spec: this.provider.chain_spec(),
                        config,
                        cancel: Default::default(),
                        best_payload: Default::default(),
                        builder_config: Default::default(),
                    };

                    let state_provider = this
                        .state_provider_factory
                        .state_provider(Some(BlockId::Hash(parent_hash.into())))
                        .await
                        .map_err(PayloadBuilderError::other)?;

                    let builder = Builder::new(|_| {
                        NoopPayloadTransactions::<BasePooledTransaction>::default()
                    });

                    builder.witness(state_provider, &ctx).map_err(PayloadBuilderError::other)
                };

                let _ = tx.send(result.await);
            });

            rx.await
                .map_err(|err| internal_rpc_err(err.to_string()))?
                .map_err(|err| internal_rpc_err(err.to_string()))
        })
        .await
    }

    async fn execution_witness(&self, block_id: BlockNumberOrTag) -> RpcResult<ExecutionWitness> {
        DebugApiExtMetrics::record_operation_async(DebugApis::DebugExecutionWitness, async {