fix: convert headers in newHeads (#20036)

klkvr · web-flow · commit b3c00ed602f2 · 2025-11-28T20:27:08.000Z
diff --git a/crates/optimism/rpc/src/eth/mod.rs b/crates/optimism/rpc/src/eth/mod.rs
@@ -194,8 +194,8 @@ where
     type NetworkTypes = Rpc::Network;
     type RpcConvert = Rpc;
 
-    fn tx_resp_builder(&self) -> &Self::RpcConvert {
-        self.inner.eth_api.tx_resp_builder()
+    fn converter(&self) -> &Self::RpcConvert {
+        self.inner.eth_api.converter()
     }
 }
 
diff --git a/crates/optimism/rpc/src/eth/transaction.rs b/crates/optimism/rpc/src/eth/transaction.rs
@@ -108,7 +108,7 @@ where
                             if let Some(flashblock) = flashblock.flatten() {
                                 // if flashblocks are supported, attempt to find id from the pending block
                                 if let Some(receipt) = flashblock
-                                .find_and_convert_transaction_receipt(hash, this.tx_resp_builder())
+                                .find_and_convert_transaction_receipt(hash, this.converter())
                                 {
                                     return receipt;
                                 }
@@ -164,7 +164,7 @@ where
                 // if flashblocks are supported, attempt to find id from the pending block
                 if let Ok(Some(pending_block)) = this.pending_flashblock().await &&
                     let Some(Ok(receipt)) = pending_block
-                        .find_and_convert_transaction_receipt(hash, this.tx_resp_builder())
+                        .find_and_convert_transaction_receipt(hash, this.converter())
                 {
                     return Ok(Some(receipt));
                 }
diff --git a/crates/primitives-traits/src/block/recovered.rs b/crates/primitives-traits/src/block/recovered.rs
@@ -668,7 +668,7 @@ mod rpc_compat {
     {
         /// Converts the block into an RPC [`Block`] with the given [`BlockTransactionsKind`].
         ///
-        /// The `tx_resp_builder` closure transforms each transaction into the desired response
+        /// The `converter` closure transforms each transaction into the desired response
         /// type.
         ///
         /// `header_builder` transforms the block header into RPC representation. It takes the
@@ -677,7 +677,7 @@ mod rpc_compat {
         pub fn into_rpc_block<T, RpcH, F, E>(
             self,
             kind: BlockTransactionsKind,
-            tx_resp_builder: F,
+            converter: F,
             header_builder: impl FnOnce(SealedHeader<B::Header>, usize) -> Result<RpcH, E>,
         ) -> Result<Block<T, RpcH>, E>
         where
@@ -688,9 +688,7 @@ mod rpc_compat {
         {
             match kind {
                 BlockTransactionsKind::Hashes => self.into_rpc_block_with_tx_hashes(header_builder),
-                BlockTransactionsKind::Full => {
-                    self.into_rpc_block_full(tx_resp_builder, header_builder)
-                }
+                BlockTransactionsKind::Full => self.into_rpc_block_full(converter, header_builder),
             }
         }
 
@@ -699,7 +697,7 @@ mod rpc_compat {
         /// For transaction hashes, only necessary parts are cloned for efficiency.
         /// For full transactions, the entire block is cloned.
         ///
-        /// The `tx_resp_builder` closure transforms each transaction into the desired response
+        /// The `converter` closure transforms each transaction into the desired response
         /// type.
         ///
         /// `header_builder` transforms the block header into RPC representation. It takes the
@@ -708,7 +706,7 @@ mod rpc_compat {
         pub fn clone_into_rpc_block<T, RpcH, F, E>(
             &self,
             kind: BlockTransactionsKind,
-            tx_resp_builder: F,
+            converter: F,
             header_builder: impl FnOnce(SealedHeader<B::Header>, usize) -> Result<RpcH, E>,
         ) -> Result<Block<T, RpcH>, E>
         where
@@ -720,7 +718,7 @@ mod rpc_compat {
             match kind {
                 BlockTransactionsKind::Hashes => self.to_rpc_block_with_tx_hashes(header_builder),
                 BlockTransactionsKind::Full => {
-                    self.clone().into_rpc_block_full(tx_resp_builder, header_builder)
+                    self.clone().into_rpc_block_full(converter, header_builder)
                 }
             }
         }
@@ -769,10 +767,10 @@ mod rpc_compat {
         /// Converts the block into an RPC [`Block`] with full transaction objects.
         ///
         /// Returns [`BlockTransactions::Full`] with complete transaction data.
-        /// The `tx_resp_builder` closure transforms each transaction with its metadata.
+        /// The `converter` closure transforms each transaction with its metadata.
         pub fn into_rpc_block_full<T, RpcHeader, F, E>(
             self,
-            tx_resp_builder: F,
+            converter: F,
             header_builder: impl FnOnce(SealedHeader<B::Header>, usize) -> Result<RpcHeader, E>,
         ) -> Result<Block<T, RpcHeader>, E>
         where
@@ -803,7 +801,7 @@ mod rpc_compat {
                         index: Some(idx as u64),
                     };
 
-                    tx_resp_builder(Recovered::new_unchecked(tx, sender), tx_info)
+                    converter(Recovered::new_unchecked(tx, sender), tx_info)
                 })
                 .collect::<Result<Vec<_>, E>>()?;
 
diff --git a/crates/rpc/rpc-builder/src/lib.rs b/crates/rpc/rpc-builder/src/lib.rs
@@ -968,7 +968,7 @@ where
                         RethRpcModule::Web3 => Web3Api::new(self.network.clone()).into_rpc().into(),
                         RethRpcModule::Txpool => TxPoolApi::new(
                             self.eth.api.pool().clone(),
-                            dyn_clone::clone(self.eth.api.tx_resp_builder()),
+                            dyn_clone::clone(self.eth.api.converter()),
                         )
                         .into_rpc()
                         .into(),
diff --git a/crates/rpc/rpc-eth-api/src/core.rs b/crates/rpc/rpc-eth-api/src/core.rs
@@ -550,7 +550,7 @@ where
         trace!(target: "rpc::eth", ?hash, "Serving eth_getTransactionByHash");
         Ok(EthTransactions::transaction_by_hash(self, hash)
             .await?
-            .map(|tx| tx.into_transaction(self.tx_resp_builder()))
+            .map(|tx| tx.into_transaction(self.converter()))
             .transpose()
             .map_err(T::Error::from)?)
     }
diff --git a/crates/rpc/rpc-eth-api/src/helpers/block.rs b/crates/rpc/rpc-eth-api/src/helpers/block.rs
@@ -59,8 +59,8 @@ pub trait EthBlocks: LoadBlock<RpcConvert: RpcConvert<Primitives = Self::Primiti
 
             let block = block.clone_into_rpc_block(
                 full.into(),
-                |tx, tx_info| self.tx_resp_builder().fill(tx, tx_info),
-                |header, size| self.tx_resp_builder().convert_header(header, size),
+                |tx, tx_info| self.converter().fill(tx, tx_info),
+                |header, size| self.converter().convert_header(header, size),
             )?;
             Ok(Some(block))
         }
@@ -155,7 +155,7 @@ pub trait EthBlocks: LoadBlock<RpcConvert: RpcConvert<Primitives = Self::Primiti
                     .collect::<Vec<_>>();
 
                 return Ok(self
-                    .tx_resp_builder()
+                    .converter()
                     .convert_receipts_with_block(inputs, block.sealed_block())
                     .map(Some)?)
             }
@@ -256,7 +256,7 @@ pub trait EthBlocks: LoadBlock<RpcConvert: RpcConvert<Primitives = Self::Primiti
                         alloy_consensus::Block::<alloy_consensus::TxEnvelope, _>::uncle(header);
                     let size = block.length();
                     let header = self
-                        .tx_resp_builder()
+                        .converter()
                         .convert_header(SealedHeader::new_unhashed(block.header), size)?;
                     Ok(Block {
                         uncles: vec![],
diff --git a/crates/rpc/rpc-eth-api/src/helpers/call.rs b/crates/rpc/rpc-eth-api/src/helpers/call.rs
@@ -172,7 +172,7 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
                             calls,
                             default_gas_limit,
                             chain_id,
-                            this.tx_resp_builder(),
+                            this.converter(),
                         )?
                     } else {
                         let evm = this.evm_config().evm_with_env(&mut db, evm_env);
@@ -182,7 +182,7 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
                             calls,
                             default_gas_limit,
                             chain_id,
-                            this.tx_resp_builder(),
+                            this.converter(),
                         )?
                     };
 
@@ -192,7 +192,7 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
                         result.block,
                         results,
                         return_full_transactions.into(),
-                        this.tx_resp_builder(),
+                        this.converter(),
                     )?;
 
                     blocks.push(block);
@@ -711,7 +711,7 @@ pub trait Call:
             request.as_mut().set_nonce(nonce);
         }
 
-        Ok(self.tx_resp_builder().tx_env(request, evm_env)?)
+        Ok(self.converter().tx_env(request, evm_env)?)
     }
 
     /// Prepares the [`reth_evm::EvmEnv`] for execution of calls.
diff --git a/crates/rpc/rpc-eth-api/src/helpers/receipt.rs b/crates/rpc/rpc-eth-api/src/helpers/receipt.rs
@@ -38,7 +38,7 @@ pub trait LoadReceipt:
                 calculate_gas_used_and_next_log_index(meta.index, &all_receipts);
 
             Ok(self
-                .tx_resp_builder()
+                .converter()
                 .convert_receipts(vec![ConvertReceiptInput {
                     tx: tx
                         .try_into_recovered_unchecked()
diff --git a/crates/rpc/rpc-eth-api/src/helpers/transaction.rs b/crates/rpc/rpc-eth-api/src/helpers/transaction.rs
@@ -290,7 +290,7 @@ pub trait EthTransactions: LoadTransaction<Provider: BlockReaderIdExt> {
                     };
 
                     return Ok(Some(
-                        self.tx_resp_builder().fill(tx.clone().with_signer(*signer), tx_info)?,
+                        self.converter().fill(tx.clone().with_signer(*signer), tx_info)?,
                     ))
                 }
             }
@@ -316,7 +316,7 @@ pub trait EthTransactions: LoadTransaction<Provider: BlockReaderIdExt> {
                     RpcNodeCore::pool(self).get_transaction_by_sender_and_nonce(sender, nonce)
             {
                 let transaction = tx.transaction.clone_into_consensus();
-                return Ok(Some(self.tx_resp_builder().fill_pending(transaction)?));
+                return Ok(Some(self.converter().fill_pending(transaction)?));
             }
 
             // Note: we can't optimize for contracts (account with code) and cannot shortcircuit if
@@ -364,9 +364,7 @@ pub trait EthTransactions: LoadTransaction<Provider: BlockReaderIdExt> {
                                 base_fee: base_fee_per_gas,
                                 index: Some(index as u64),
                             };
-                            Ok(self
-                                .tx_resp_builder()
-                                .fill(tx.clone().with_signer(*signer), tx_info)?)
+                            Ok(self.converter().fill(tx.clone().with_signer(*signer), tx_info)?)
                         })
                 })
                 .ok_or(EthApiError::HeaderNotFound(block_id))?
@@ -509,7 +507,7 @@ pub trait EthTransactions: LoadTransaction<Provider: BlockReaderIdExt> {
                 }
             }
 
-            let tx = self.tx_resp_builder().build_simulate_v1_transaction(request)?;
+            let tx = self.converter().build_simulate_v1_transaction(request)?;
 
             let raw = tx.encoded_2718().into();
 
diff --git a/crates/rpc/rpc-eth-api/src/types.rs b/crates/rpc/rpc-eth-api/src/types.rs
@@ -30,7 +30,7 @@ pub trait EthApiTypes: Send + Sync + Clone {
     type RpcConvert: RpcConvert<Network = Self::NetworkTypes>;
 
     /// Returns reference to transaction response builder.
-    fn tx_resp_builder(&self) -> &Self::RpcConvert;
+    fn converter(&self) -> &Self::RpcConvert;
 }
 
 /// Adapter for network specific block type.
diff --git a/crates/rpc/rpc-eth-types/src/simulate.rs b/crates/rpc/rpc-eth-types/src/simulate.rs
@@ -65,7 +65,7 @@ pub fn execute_transactions<S, T>(
     calls: Vec<RpcTxReq<T::Network>>,
     default_gas_limit: u64,
     chain_id: u64,
-    tx_resp_builder: &T,
+    converter: &T,
 ) -> Result<
     (
         BlockBuilderOutcome<S::Primitives>,
@@ -89,7 +89,7 @@ where
             builder.evm().block().basefee(),
             chain_id,
             builder.evm_mut().db_mut(),
-            tx_resp_builder,
+            converter,
         )?;
         // Create transaction with an empty envelope.
         // The effect for a layer-2 execution client is that it does not charge L1 cost.
@@ -117,7 +117,7 @@ pub fn resolve_transaction<DB: Database, Tx, T>(
     block_base_fee_per_gas: u64,
     chain_id: u64,
     db: &mut DB,
-    tx_resp_builder: &T,
+    converter: &T,
 ) -> Result<Recovered<Tx>, EthApiError>
 where
     DB::Error: Into<EthApiError>,
@@ -175,9 +175,8 @@ where
         }
     }
 
-    let tx = tx_resp_builder
-        .build_simulate_v1_transaction(tx)
-        .map_err(|e| EthApiError::other(e.into()))?;
+    let tx =
+        converter.build_simulate_v1_transaction(tx).map_err(|e| EthApiError::other(e.into()))?;
 
     Ok(Recovered::new_unchecked(tx, from))
 }
@@ -187,7 +186,7 @@ pub fn build_simulated_block<Err, T>(
     block: RecoveredBlock<BlockTy<T::Primitives>>,
     results: Vec<ExecutionResult<HaltReasonFor<T::Evm>>>,
     txs_kind: BlockTransactionsKind,
-    tx_resp_builder: &T,
+    converter: &T,
 ) -> Result<SimulatedBlock<RpcBlock<T::Network>>, Err>
 where
     Err: std::error::Error
@@ -256,8 +255,8 @@ where
 
     let block = block.into_rpc_block(
         txs_kind,
-        |tx, tx_info| tx_resp_builder.fill(tx, tx_info),
-        |header, size| tx_resp_builder.convert_header(header, size),
+        |tx, tx_info| converter.fill(tx, tx_info),
+        |header, size| converter.convert_header(header, size),
     )?;
     Ok(SimulatedBlock { inner: block, calls })
 }
diff --git a/crates/rpc/rpc/src/eth/core.rs b/crates/rpc/rpc/src/eth/core.rs
@@ -190,8 +190,8 @@ where
     type NetworkTypes = Rpc::Network;
     type RpcConvert = Rpc;
 
-    fn tx_resp_builder(&self) -> &Self::RpcConvert {
-        &self.tx_resp_builder
+    fn converter(&self) -> &Self::RpcConvert {
+        &self.converter
     }
 }
 
@@ -303,7 +303,7 @@ pub struct EthApiInner<N: RpcNodeCore, Rpc: RpcConvert> {
     raw_tx_forwarder: Option<RpcClient>,
 
     /// Converter for RPC types.
-    tx_resp_builder: Rpc,
+    converter: Rpc,
 
     /// Builder for pending block environment.
     next_env_builder: Box<dyn PendingEnvBuilder<N::Evm>>,
@@ -343,7 +343,7 @@ where
         fee_history_cache: FeeHistoryCache<ProviderHeader<N::Provider>>,
         task_spawner: Box<dyn TaskSpawner + 'static>,
         proof_permits: usize,
-        tx_resp_builder: Rpc,
+        converter: Rpc,
         next_env: impl PendingEnvBuilder<N::Evm>,
         max_batch_size: usize,
         pending_block_kind: PendingBlockKind,
@@ -386,7 +386,7 @@ where
             blocking_task_guard: BlockingTaskGuard::new(proof_permits),
             raw_tx_sender,
             raw_tx_forwarder,
-            tx_resp_builder,
+            converter,
             next_env_builder: Box::new(next_env),
             tx_batch_sender,
             pending_block_kind,
@@ -410,8 +410,8 @@ where
 
     /// Returns a handle to the transaction response builder.
     #[inline]
-    pub const fn tx_resp_builder(&self) -> &Rpc {
-        &self.tx_resp_builder
+    pub const fn converter(&self) -> &Rpc {
+        &self.converter
     }
 
     /// Returns a handle to data in memory.
diff --git a/crates/rpc/rpc/src/eth/filter.rs b/crates/rpc/rpc/src/eth/filter.rs
@@ -359,7 +359,7 @@ where
                 let stream = self.pool().new_pending_pool_transactions_listener();
                 let full_txs_receiver = FullTransactionsReceiver::new(
                     stream,
-                    dyn_clone::clone(self.inner.eth_api.tx_resp_builder()),
+                    dyn_clone::clone(self.inner.eth_api.converter()),
                 );
                 FilterKind::PendingTransaction(PendingTransactionKind::FullTransaction(Arc::new(
                     full_txs_receiver,
@@ -779,7 +779,7 @@ impl PendingTransactionsReceiver {
 #[derive(Debug, Clone)]
 struct FullTransactionsReceiver<T: PoolTransaction, TxCompat> {
     txs_stream: Arc<Mutex<NewSubpoolTransactionStream<T>>>,
-    tx_resp_builder: TxCompat,
+    converter: TxCompat,
 }
 
 impl<T, TxCompat> FullTransactionsReceiver<T, TxCompat>
@@ -788,8 +788,8 @@ where
     TxCompat: RpcConvert<Primitives: NodePrimitives<SignedTx = T::Consensus>>,
 {
     /// Creates a new `FullTransactionsReceiver` encapsulating the provided transaction stream.
-    fn new(stream: NewSubpoolTransactionStream<T>, tx_resp_builder: TxCompat) -> Self {
-        Self { txs_stream: Arc::new(Mutex::new(stream)), tx_resp_builder }
+    fn new(stream: NewSubpoolTransactionStream<T>, converter: TxCompat) -> Self {
+        Self { txs_stream: Arc::new(Mutex::new(stream)), converter }
     }
 
     /// Returns all new pending transactions received since the last poll.
@@ -798,7 +798,7 @@ where
         let mut prepared_stream = self.txs_stream.lock().await;
 
         while let Ok(tx) = prepared_stream.try_recv() {
-            match self.tx_resp_builder.fill_pending(tx.transaction.to_consensus()) {
+            match self.converter.fill_pending(tx.transaction.to_consensus()) {
                 Ok(tx) => pending_txs.push(tx),
                 Err(err) => {
                     error!(target: "rpc",
diff --git a/crates/rpc/rpc/src/eth/pubsub.rs b/crates/rpc/rpc/src/eth/pubsub.rs
diff --git a/crates/rpc/rpc/src/txpool.rs b/crates/rpc/rpc/src/txpool.rs

Original file line number	Diff line number	Diff line change
`@@ -194,8 +194,8 @@ where`
`194`	`194`	`type NetworkTypes = Rpc::Network;`
`195`	`195`	`type RpcConvert = Rpc;`
`196`	`196`
`197`		`- fn tx_resp_builder(&self) -> &Self::RpcConvert {`
`198`		`- self.inner.eth_api.tx_resp_builder()`
	`197`	`+ fn converter(&self) -> &Self::RpcConvert {`
	`198`	`+ self.inner.eth_api.converter()`
`199`	`199`	`}`
`200`	`200`	`}`
`201`	`201`
Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ where`
`108`	`108`	`if let Some(flashblock) = flashblock.flatten() {`
`109`	`109`	`// if flashblocks are supported, attempt to find id from the pending block`
`110`	`110`	`if let Some(receipt) = flashblock`
`111`		`- .find_and_convert_transaction_receipt(hash, this.tx_resp_builder())`
	`111`	`+ .find_and_convert_transaction_receipt(hash, this.converter())`
`112`	`112`	`{`
`113`	`113`	`return receipt;`
`114`	`114`	`}`
`@@ -164,7 +164,7 @@ where`
`164`	`164`	`// if flashblocks are supported, attempt to find id from the pending block`
`165`	`165`	`if let Ok(Some(pending_block)) = this.pending_flashblock().await &&`
`166`	`166`	`let Some(Ok(receipt)) = pending_block`
`167`		`- .find_and_convert_transaction_receipt(hash, this.tx_resp_builder())`
	`167`	`+ .find_and_convert_transaction_receipt(hash, this.converter())`
`168`	`168`	`{`
`169`	`169`	`return Ok(Some(receipt));`
`170`	`170`	`}`
Original file line number	Diff line number	Diff line change
`@@ -968,7 +968,7 @@ where`
`968`	`968`	`RethRpcModule::Web3 => Web3Api::new(self.network.clone()).into_rpc().into(),`
`969`	`969`	`RethRpcModule::Txpool => TxPoolApi::new(`
`970`	`970`	`self.eth.api.pool().clone(),`
`971`		`- dyn_clone::clone(self.eth.api.tx_resp_builder()),`
	`971`	`+ dyn_clone::clone(self.eth.api.converter()),`
`972`	`972`	`)`
`973`	`973`	`.into_rpc()`
`974`	`974`	`.into(),`
Original file line number	Diff line number	Diff line change
`@@ -550,7 +550,7 @@ where`
`550`	`550`	`trace!(target: "rpc::eth", ?hash, "Serving eth_getTransactionByHash");`
`551`	`551`	`Ok(EthTransactions::transaction_by_hash(self, hash)`
`552`	`552`	`.await?`
`553`		`- .map(\|tx\| tx.into_transaction(self.tx_resp_builder()))`
	`553`	`+ .map(\|tx\| tx.into_transaction(self.converter()))`
`554`	`554`	`.transpose()`
`555`	`555`	`.map_err(T::Error::from)?)`
`556`	`556`	`}`
Original file line number	Diff line number	Diff line change
`@@ -290,7 +290,7 @@ pub trait EthTransactions: LoadTransaction<Provider: BlockReaderIdExt> {`
`290`	`290`	`};`
`291`	`291`
`292`	`292`	`return Ok(Some(`
`293`		`- self.tx_resp_builder().fill(tx.clone().with_signer(*signer), tx_info)?,`
	`293`	`+ self.converter().fill(tx.clone().with_signer(*signer), tx_info)?,`
`294`	`294`	`))`
`295`	`295`	`}`
`296`	`296`	`}`
`@@ -316,7 +316,7 @@ pub trait EthTransactions: LoadTransaction<Provider: BlockReaderIdExt> {`
`316`	`316`	`RpcNodeCore::pool(self).get_transaction_by_sender_and_nonce(sender, nonce)`
`317`	`317`	`{`
`318`	`318`	`let transaction = tx.transaction.clone_into_consensus();`
`319`		`- return Ok(Some(self.tx_resp_builder().fill_pending(transaction)?));`
	`319`	`+ return Ok(Some(self.converter().fill_pending(transaction)?));`
`320`	`320`	`}`
`321`	`321`
`322`	`322`	`// Note: we can't optimize for contracts (account with code) and cannot shortcircuit if`
`@@ -364,9 +364,7 @@ pub trait EthTransactions: LoadTransaction<Provider: BlockReaderIdExt> {`
`364`	`364`	`base_fee: base_fee_per_gas,`
`365`	`365`	`index: Some(index as u64),`
`366`	`366`	`};`
`367`		`- Ok(self`
`368`		`- .tx_resp_builder()`
`369`		`- .fill(tx.clone().with_signer(*signer), tx_info)?)`
	`367`	`+ Ok(self.converter().fill(tx.clone().with_signer(*signer), tx_info)?)`
`370`	`368`	`})`
`371`	`369`	`})`
`372`	`370`	`.ok_or(EthApiError::HeaderNotFound(block_id))?`
`@@ -509,7 +507,7 @@ pub trait EthTransactions: LoadTransaction<Provider: BlockReaderIdExt> {`
`509`	`507`	`}`
`510`	`508`	`}`
`511`	`509`
`512`		`- let tx = self.tx_resp_builder().build_simulate_v1_transaction(request)?;`
	`510`	`+ let tx = self.converter().build_simulate_v1_transaction(request)?;`
`513`	`511`
`514`	`512`	`let raw = tx.encoded_2718().into();`
`515`	`513`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ pub trait EthApiTypes: Send + Sync + Clone {`
`30`	`30`	`type RpcConvert: RpcConvert<Network = Self::NetworkTypes>;`
`31`	`31`
`32`	`32`	`/// Returns reference to transaction response builder.`
`33`		`- fn tx_resp_builder(&self) -> &Self::RpcConvert;`
	`33`	`+ fn converter(&self) -> &Self::RpcConvert;`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`/// Adapter for network specific block type.`