How do I create a transaction that fits the transaction type of add_transaction_and_subscribe of pool?

[djm07073]

I’m developing a Reth extension that monitors and reacts to transactions meeting specific conditions. As part of this, I need to insert transactions into the pool within the components of the ExExContext.

However, since there are multiple transaction rust types involved, I’m unsure which one is appropriate to use when constructing a new transaction for insertion.

Currently, I’m using alloy::rpc::types::TransactionRequest to construct a transaction as shown below:

use alloy::rpc::types::TransactionRequest;
...
let tx = TransactionRequest::default()
            .with_to(to)
            .with_nonce(nonce)
            .with_chain_id(self.chain_id)
            .with_gas_limit(21_000)
            .with_max_priority_fee_per_gas(max_priority_fee_per_gas)
            .with_max_fee_per_gas(max_fee_per_gas);

 let wallet = EthereumWallet::from(relayer.signer);
 let tx_envelope = tx.build(&wallet).await?;
// HELP
 let tx_events = self.fnc.pool().add_transaction_and_subscribe(TransactionOrigin::Local, tx_envelope).await?;

If I’m misunderstanding how add_transaction_and_subscribe works, I would appreciate it if you could clarify that. Otherwise, I’d be grateful if you could explain the correct way to construct and insert a transaction into the pool.

[mattsse]

this should be doable via

reth/crates/transaction-pool/src/traits.rs

Lines 1064 to 1070 in 3fc463c

	/// Tries to convert the `Consensus` type with a blob sidecar into the `Pooled` type.
	///
	/// Returns `None` if passed transaction is not a blob transaction.
	fn try_from_eip4844(
	tx: Recovered<Self::Consensus>,
	sidecar: BlobTransactionSidecarVariant,
	) -> Option<Self>;

see also:

reth/crates/rpc/rpc-eth-api/src/helpers/transaction.rs

Lines 366 to 372 in 3fc463c

	let transaction = self.sign_request(&from, request).await?.with_signer(from);
	let pool_transaction =
	<<Self as RpcNodeCore>::Pool as TransactionPool>::Transaction::try_from_consensus(
	transaction,
	)
	.map_err(|_| EthApiError::TransactionConversionError)?;

[djm07073]

Sorry here is the other problem in mismatching type i used 🥲
II'm trying to use alloy's NetworkWallet with reth's transaction pool, but I'm getting a type mismatch error when try_from_consensus.

let request = TransactionRequest::default()
    .with_to(to)
    .with_input(data)
    .with_nonce(nonce)
    .with_chain_id(self.chain_id)
    .with_gas_limit(gas_limit)
    .with_max_priority_fee_per_gas(max_priority_fee_per_gas)
    .with_max_fee_per_gas(max_fee_per_gas);

let transaction = NetworkWallet::<Ethereum>
    ::sign_request(&relayer.wallet, request.clone()).await
    .map_err(|e| eyre::eyre!("Failed to sign transaction: {:?}", e))?
    .with_signer(from);

let pool_transaction = <FC::Pool as TransactionPool>::Transaction
    ::try_from_consensus(transaction)
    .map_err(|e| eyre::eyre!("Failed to convert to pool transaction: {:?}", e))?;

error

error[E0308]: mismatched types
expected struct `Recovered<<<<FC as FullNodeTypes>::Types as NodeTypes>::Primitives as NodePrimitives>::SignedTx>`
found struct `Recovered<alloy_consensus::transaction::envelope::EthereumTxEnvelope<alloy_consensus::transaction::eip4844::TxEip4844Variant>>`

The error suggests that try_from_consensus expects a Recovered containing the node's specific SignedTx type, but I'm providing a Recovered from alloy

How should I properly solve between these types?

• Should I convert the EthereumTxEnvelope to the node's SignedTx type first?
• Or should I be using a different approach entirely for submitting transactions from alloy wallets to reth's pool without provider type?

Version i used

• reth v1.3.12
• alloy-network v0.14.0

[djm07073]

@mattsse I was looking to sign a transaction using a private key signer and add it to the pool without using a provider. Would appreciate your answer when you have a moment 🙏

[mattsse]

can you share more of your function signature, because I think you'd need to restrict Primitives = EthPrimitives for example

[djm07073]

function signature and broader context:

use alloy_network::{ Ethereum, EthereumWallet, NetworkWallet };
use alloy_primitives::{ Address, ChainId, FixedBytes };
use reth::api::FullNodeComponents;
use reth::rpc::types::TransactionRequest;
use reth::transaction_pool::{ TransactionPool, TransactionOrigin };
use reth_transaction_pool::PoolTransaction;

pub struct RelayerPool<FC: FullNodeComponents> {
    fnc: FC,
    wallet: EthereumWallet,
    // ... other fields
}

impl<FC> RelayerPool<FC>
where 
    FC: FullNodeComponents, 
    <FC::Pool as TransactionPool>::Transaction: PoolTransaction
{
    async fn send_transaction(&self, to: Address, data: Vec<u8>) -> Result<FixedBytes<32>> {
        let request = TransactionRequest::default()
            .with_to(to)
            .with_input(data)
            .with_nonce(nonce)
            .with_chain_id(self.chain_id)
            .with_gas_limit(gas_limit)
            .with_max_priority_fee_per_gas(max_priority_fee_per_gas)
            .with_max_fee_per_gas(max_fee_per_gas);

        // This returns Recovered<Recovered<EthereumTxEnvelope<aTxEip4844Variant>>> from alloy
        let transaction = NetworkWallet::<Ethereum>
            ::sign_request(&self.wallet, request.clone()).await?
            .with_signer(from);

        // ERROR: This expects Recovered<<<<FC as FullNodeTypes>::Types as NodeTypes>::Primitives as NodePrimitives>::SignedTx>
        let pool_transaction = <FC::Pool as TransactionPool>::Transaction
            ::try_from_consensus(transaction)  // <-- Type mismatch here
            .map_err(|e| eyre::eyre!("Failed to convert to pool transaction: {:?}", e))?;
            
        let mut tx_events = self.fnc
            .pool()
            .add_transaction_and_subscribe(TransactionOrigin::Local, pool_transaction).await?;
        
        // ... rest of the function
    }
}

maybe there is a type mismatch between alloy transaction types and reth expected transaction types?

[djm07073]

@mattsse 🙏

[mattsse]

sorry @djm07073, forgot to follow up here

added this as part of an example:

#17420

[djm07073]

thank you for sharing the example.

in my case. i use this way (looks like the same thing).

let request = TransactionRequest {
            to: Some(TxKind::Call(message.to)),
            input: TransactionInput::new(message.calldata.into()),
            access_list: Some(message.access_list),
            nonce: Some(nonce),
            chain_id: Some(self.chain_id),
            gas: Some(gas_limit),
            max_priority_fee_per_gas: Some(priority_fee),
            max_fee_per_gas: Some(max_fee_per_gas),
            ..Default::default()
        };

        let tx_envelope = NetworkWallet::<Ethereum>::sign_request(self.wallet.wallet(), request)
            .await
            .map_err(|e| eyre::eyre!("Failed to sign transaction: {:?}", e))?;

        let reth_signed_tx: TransactionSigned = tx_envelope.into();
        let recovered_tx = Recovered::new_unchecked(reth_signed_tx, from);
        let len = recovered_tx.encode_2718_len();
        // eth pool transaction
        let eth_pooled_tx = EthPooledTransaction::new(recovered_tx, len);

[mattsse]

yeah this also works, I opened this #17421 to make that easier