Add reth_rpc_types::Transaction to reth_primitives::Transaction conversion util function

[Eikix]

Describe the feature

Hi all!

Context

I've noticed that one can go from reth_primitives::TransactionSignedEcRecovered to reth_rpc_types:Transaction with rpc-types-compat::from_recovered util.
I'd like to have a util to go the opposite route, to the best of my knowledge it does not exist.

Proposed added code

In rpc-types-compat crate, add a util: rpc_transaction_to_primitive

pub fn rpc_transaction_to_primitive(
    rpc_transaction: reth_rpc_types::Transaction,
) -> Result<reth_primitives::Transaction, ConversionError> {
    match rpc_transaction.transaction_type {
        None => Err(ConversionError::TransactionConversionError("Transaction type not found".to_string())),
        Some(transaction_type) => match transaction_type.to::<u64>() {
            0 => Ok(reth_primitives::Transaction::Legacy(TxLegacy {
                nonce: rpc_transaction.nonce.to::<u64>(),
                gas_price: rpc_transaction
                    .gas_price
                    .ok_or(ConversionError::TransactionConversionError("Gas price not found".to_string()))?
                    .to::<u128>(),
                gas_limit: rpc_transaction
                    .gas
                    .try_into()
                    .map_err(|_| ConversionError::ValueOutOfRange("Block number too large".to_string()))?,
                to: rpc_transaction.to.map_or_else(|| TransactionKind::Create, TransactionKind::Call),
                value: rpc_transaction.value.into(),
                input: rpc_transaction.input,
                chain_id: rpc_transaction.chain_id.map(|id| id.to::<u64>()),
            })),
            1 => Ok(reth_primitives::Transaction::Eip2930(TxEip2930 {
                chain_id: rpc_transaction
                    .chain_id
                    .ok_or(ConversionError::TransactionConversionError("Chain id not found".to_string()))?
                    .to::<u64>(),
                nonce: rpc_transaction.nonce.to::<u64>(),
                gas_price: rpc_transaction
                    .gas_price
                    .ok_or(ConversionError::TransactionConversionError("Gas price not found".to_string()))?
                    .to::<u128>(),
                gas_limit: rpc_transaction
                    .gas
                    .try_into()
                    .map_err(|_| ConversionError::ValueOutOfRange("Block number too large".to_string()))?,
                to: rpc_transaction.to.map_or_else(|| TransactionKind::Create, TransactionKind::Call),
                value: rpc_transaction.value.into(),
                access_list: AccessList(
                    rpc_transaction
                        .access_list
                        .unwrap_or_default()
                        .into_iter()
                        .map(|access_list| AccessListItem {
                            address: access_list.address,
                            storage_keys: access_list.storage_keys,
                        })
                        .collect(),
                ),
                input: rpc_transaction.input,
            })),
            2 => Ok(reth_primitives::Transaction::Eip1559(TxEip1559 {
                chain_id: rpc_transaction
                    .chain_id
                    .ok_or(ConversionError::TransactionConversionError("Chain id not found".to_string()))?
                    .to::<u64>(),
                nonce: rpc_transaction.nonce.to::<u64>(),
                gas_limit: rpc_transaction
                    .gas
                    .try_into()
                    .map_err(|_| ConversionError::ValueOutOfRange("Block number too large".to_string()))?,
                max_fee_per_gas: rpc_transaction
                    .max_fee_per_gas
                    .ok_or(ConversionError::TransactionConversionError("Max fee per gas not found".to_string()))?
                    .to::<u128>(),
                max_priority_fee_per_gas: rpc_transaction
                    .max_priority_fee_per_gas
                    .ok_or(ConversionError::TransactionConversionError(
                        "Max priority fee per gas not found".to_string(),
                    ))?
                    .to::<u128>(),
                to: rpc_transaction.to.map_or_else(|| TransactionKind::Create, TransactionKind::Call),
                value: rpc_transaction.value.into(),
                access_list: AccessList(
                    rpc_transaction
                        .access_list
                        .unwrap_or_default()
                        .into_iter()
                        .map(|access_list| AccessListItem {
                            address: access_list.address,
                            storage_keys: access_list.storage_keys,
                        })
                        .collect(),
                ),
                input: rpc_transaction.input,
            })),
            _ => Err(ConversionError::TransactionConversionError("Invalid transaction type".to_string())),
        },
    }
}

The above code is done for kakarot zkevm's rpc layer that heavily relies on reth types (thank you btw 🙏)

Can adapt API / Rework as this is a first /fast try.

Thanks!

Additional context

No response

[DaniPopes]

cc @mattsse

[mattsse]

supportive, this should be a tryFrom impl in reth-primitives