Method insert_validated_transaction

crates/execution/txpool/src/builder/rpc.rs:88–178

(&self, tx: ValidatedTransaction<E>)

    E: ValidatedTransactionExtensions<BasePooledTransaction>,
{
    async fn insert_validated_transaction(&self, tx: ValidatedTransaction<E>) -> RpcResult<()> {
        debug!(
            sender = %tx.sender,
            "rpc::insert_validated_transaction"
        );
        let sender = tx.sender;
        let has_extensions = !tx.extensions.is_empty();

        if has_extensions && !self.accept_extensions {
            BuilderApiMetrics::extension_errors().increment(1);
            return Err(ErrorObjectOwned::owned(
                ErrorCode::InvalidParams.code(),
                "transaction extensions are disabled",
                None::<()>,
            ));
        }

        tx.extensions.validate(self.max_extension_items).map_err(|e| {
            BuilderApiMetrics::extension_errors().increment(1);
            ErrorObjectOwned::owned(ErrorCode::InvalidParams.code(), e.to_string(), None::<()>)
        })?;

        // Decode the EIP-2718 transaction bytes
        let consensus_tx =
            BaseTransactionSigned::decode_2718(&mut tx.raw.as_ref()).map_err(|e| {
                BuilderApiMetrics::decode_errors().increment(1);
                ErrorObjectOwned::owned(
                    ErrorCode::InvalidParams.code(),
                    format!("failed to decode transaction: {e}"),
                    None::<()>,
                )
            })?;
        let tx_hash = *consensus_tx.hash();
        let encoded_len = tx.raw.len();

        let recovered = Recovered::new_unchecked(consensus_tx, sender);
        let pool_tx = BasePooledTransaction::new(recovered, encoded_len).with_bundle_metadata(
            tx.min_block_number,
            tx.max_block_number,
            tx.min_timestamp,
            tx.max_timestamp,
        );

        // Attach any extension data carried on the wire. This is a no-op for
        // `NoExtensions`, the default payload.
        let pool_tx = tx.extensions.apply(pool_tx).map_err(|e| {
            BuilderApiMetrics::extension_errors().increment(1);
            ErrorObjectOwned::owned(ErrorCode::InvalidParams.code(), e.to_string(), None::<()>)
        })?;

        // Extension-bearing transactions remain private so normal P2P gossip
        // cannot propagate the raw transaction without its extension metadata.
        let start = Instant::now();
        let result = if has_extensions {
            self.pool.add_transaction(TransactionOrigin::Private, pool_tx).await
        } else {
            self.pool.add_external_transaction(pool_tx).await
        };