Add txpool RPC and impl new_pending_transaction_filter (#1073)

* Add new filter type

* Add txpool client side

* Fix node compile

* Fix rpc

* Dev filter_changes

* Add feature and format

* Use sp_core::hashing

* Fix clippy

* Format code

* Add pending transaction polling ts tests

* Add txpool ts-test

* Fix clippy CI

* Fix review

* Remove `TxPoolRuntimeApi`

* Clean trait bound

* Clean trait bound

* Remove feature `txpool`

client/rpc-core/src/lib.rs

@@ -23,11 +23,13 @@ pub mod types;
 mod eth;
 mod eth_pubsub;
 mod net;
+mod txpool;
 mod web3;
 
 pub use self::{
  eth::{EthApiServer, EthFilterApiServer},
  eth_pubsub::EthPubSubApiServer,
  net::NetApiServer,
+ txpool::TxPoolApiServer,
  web3::Web3ApiServer,
 };

client/rpc-core/src/txpool.rs

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+// This file is part of Frontier.
+//
+// Copyright (c) 2015-2022 Parity Technologies (UK) Ltd.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+//! tx pool rpc interface
+
+use ethereum_types::U256;
+use jsonrpsee::{core::RpcResult, proc_macros::rpc};
+// Frontier
+use crate::types::*;
+
+/// TxPool rpc interface
+#[rpc(server)]
+pub trait TxPoolApi {
+ #[method(name = "txpool_content")]
+ fn content(&self) -> RpcResult<TxPoolResult<TransactionMap<TxPoolTransaction>>>;
+
+ #[method(name = "txpool_inspect")]
+ fn inspect(&self) -> RpcResult<TxPoolResult<TransactionMap<Summary>>>;
+
+ #[method(name = "txpool_status")]
+ fn status(&self) -> RpcResult<TxPoolResult<U256>>;
+}

client/rpc-core/src/types/filter.rs

@@ -17,7 +17,7 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 use std::{
- collections::BTreeMap,
+ collections::{BTreeMap, HashSet},
  sync::{Arc, Mutex},
 };
 
@@ -460,6 +460,7 @@ pub struct FilterPoolItem {
  pub last_poll: BlockNumber,
  pub filter_type: FilterType,
  pub at_block: u64,
+ pub pending_transaction_hashes: HashSet<H256>,
 }
 
 /// On-memory stored filters created through the `eth_newFilter` RPC.

client/rpc-core/src/types/mod.rs

@@ -31,6 +31,7 @@ mod receipt;
 mod sync;
 mod transaction;
 mod transaction_request;
+mod txpool;
 mod work;
 
 pub mod pubsub;
@@ -55,5 +56,6 @@ pub use self::{
  },
  transaction::{LocalTransactionStatus, RichRawTransaction, Transaction},
  transaction_request::{TransactionMessage, TransactionRequest},
+ txpool::{Get, Summary, TransactionMap, TxPoolResult, TxPoolTransaction},
  work::Work,
 };

client/rpc-core/src/types/txpool.rs

@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+// This file is part of Frontier.
+//
+// Copyright (c) 2015-2022 Parity Technologies (UK) Ltd.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+use std::collections::HashMap;
+
+use ethereum::{TransactionAction, TransactionV2 as EthereumTransaction};
+use ethereum_types::{H160, H256, U256};
+use serde::{Serialize, Serializer};
+// Frontier
+use crate::types::Bytes;
+
+pub type TransactionMap<T> = HashMap<H160, HashMap<U256, T>>;
+
+pub trait Get {
+ fn get(hash: H256, from_address: H160, txn: &EthereumTransaction) -> Self;
+}
+
+#[derive(Debug, Serialize)]
+pub struct TxPoolResult<T: Serialize> {
+ pub pending: T,
+ pub queued: T,
+}
+
+#[derive(Clone, Debug)]
+pub struct Summary {
+ pub to: Option<H160>,
+ pub value: U256,
+ pub gas: U256,
+ pub gas_price: U256,
+}
+
+impl Serialize for Summary {
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ let res = format!(
+ "0x{:x}: {} wei + {} gas x {} wei",
+ self.to.unwrap_or_default(),
+ self.value,
+ self.gas,
+ self.gas_price
+ );
+ serializer.serialize_str(&res)
+ }
+}
+
+impl Get for Summary {
+ fn get(_hash: H256, _from_address: H160, txn: &EthereumTransaction) -> Self {
+ let (action, value, gas_price, gas_limit) = match txn {
+ EthereumTransaction::Legacy(t) => (t.action, t.value, t.gas_price, t.gas_limit),
+ EthereumTransaction::EIP2930(t) => (t.action, t.value, t.gas_price, t.gas_limit),
+ EthereumTransaction::EIP1559(t) => (t.action, t.value, t.max_fee_per_gas, t.gas_limit),
+ };
+ Self {
+ to: match action {
+ TransactionAction::Call(to) => Some(to),
+ _ => None,
+ },
+ value,
+ gas_price,
+ gas: gas_limit,
+ }
+ }
+}
+
+#[derive(Debug, Default, Clone, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TxPoolTransaction {
+ /// Hash
+ pub hash: H256,
+ /// Nonce
+ pub nonce: U256,
+ /// Block hash
+ #[serde(serialize_with = "block_hash_serialize")]
+ pub block_hash: Option<H256>,
+ /// Block number
+ pub block_number: Option<U256>,
+ /// Sender
+ pub from: H160,
+ /// Recipient
+ #[serde(serialize_with = "to_serialize")]
+ pub to: Option<H160>,
+ /// Transfered value
+ pub value: U256,
+ /// Gas Price
+ pub gas_price: U256,
+ /// Gas
+ pub gas: U256,
+ /// Data
+ pub input: Bytes,
+ /// Transaction Index
+ pub transaction_index: Option<U256>,
+}
+
+fn block_hash_serialize<S>(hash: &Option<H256>, serializer: S) -> Result<S::Ok, S::Error>
+where
+ S: Serializer,
+{
+ serializer.serialize_str(&format!("0x{:x}", hash.unwrap_or_default()))
+}
+
+fn to_serialize<S>(hash: &Option<H160>, serializer: S) -> Result<S::Ok, S::Error>
+where
+ S: Serializer,
+{
+ serializer.serialize_str(&format!("0x{:x}", hash.unwrap_or_default()))
+}
+
+impl Get for TxPoolTransaction {
+ fn get(hash: H256, from_address: H160, txn: &EthereumTransaction) -> Self {
+ let (nonce, action, value, gas_price, gas_limit, input) = match txn {
+ EthereumTransaction::Legacy(t) => (
+ t.nonce,
+ t.action,
+ t.value,
+ t.gas_price,
+ t.gas_limit,
+ t.input.clone(),
+ ),
+ EthereumTransaction::EIP2930(t) => (
+ t.nonce,
+ t.action,
+ t.value,
+ t.gas_price,
+ t.gas_limit,
+ t.input.clone(),
+ ),
+ EthereumTransaction::EIP1559(t) => (
+ t.nonce,
+ t.action,
+ t.value,
+ t.max_fee_per_gas,
+ t.gas_limit,
+ t.input.clone(),
+ ),
+ };
+ Self {
+ hash,
+ nonce,
+ block_hash: None,
+ block_number: None,
+ from: from_address,
+ to: match action {
+ TransactionAction::Call(to) => Some(to),
+ _ => None,
+ },
+ value,
+ gas_price,
+ gas: gas_limit,
+ input: Bytes(input),
+ transaction_index: None,
+ }
+ }
+}

client/rpc/Cargo.toml

@@ -24,6 +24,7 @@ prometheus = { version = "0.13.1", default-features = false }
 rand = "0.8"
 rlp = { workspace = true }
 scale-codec = { package = "parity-scale-codec", workspace = true }
+serde = { workspace = true }
 tokio = { version = "1.24", features = ["sync"] }
 
 # Substrate