cfx_rpc_eth_api/
eth.rs

1use cfx_rpc_eth_types::{
2    AccessListResult, AccountPendingTransactions, Block, BlockId,
3    BlockOverrides, Bundle, EthCallResponse, EthRpcLogFilter as Filter,
4    FeeHistory, Header, Log, Receipt, RpcStateOverride, SimulatePayload,
5    SimulatedBlock, StateContext, SyncStatus, Transaction, TransactionRequest,
6};
7use cfx_rpc_primitives::{Bytes, Index};
8use cfx_types::{Address, H256, H64, U256, U64};
9use jsonrpsee::{core::RpcResult, proc_macros::rpc};
10
11type BlockNumberOrTag = BlockId;
12
13type JsonStorageKey = U256;
14
15#[rpc(server, namespace = "eth")]
16pub trait EthApi {
17    /// Returns the protocol version encoded as a string.
18    #[method(name = "protocolVersion")]
19    async fn protocol_version(&self) -> RpcResult<U64>;
20
21    /// Returns an object with data about the sync status or false.
22    #[method(name = "syncing")]
23    fn syncing(&self) -> RpcResult<SyncStatus>;
24
25    /// Returns the client coinbase address.
26    #[method(name = "coinbase")]
27    async fn author(&self) -> RpcResult<Address>;
28
29    /// Returns a list of addresses owned by client.
30    #[method(name = "accounts")]
31    fn accounts(&self) -> RpcResult<Vec<Address>>;
32
33    /// Returns the number of most recent block.
34    #[method(name = "blockNumber")]
35    fn block_number(&self) -> RpcResult<U256>;
36
37    /// Returns the chain ID of the current network.
38    #[method(name = "chainId")]
39    async fn chain_id(&self) -> RpcResult<Option<U64>>;
40
41    /// Returns information about a block by hash.
42    #[method(name = "getBlockByHash")]
43    async fn block_by_hash(
44        &self, hash: H256, full: bool,
45    ) -> RpcResult<Option<Block>>;
46
47    /// Returns information about a block by number.
48    #[method(name = "getBlockByNumber")]
49    async fn block_by_number(
50        &self, number: BlockNumberOrTag, full: bool,
51    ) -> RpcResult<Option<Block>>;
52
53    /// Returns the number of transactions in a block from a block matching the
54    /// given block hash.
55    #[method(name = "getBlockTransactionCountByHash")]
56    async fn block_transaction_count_by_hash(
57        &self, hash: H256,
58    ) -> RpcResult<Option<U256>>;
59
60    /// Returns the number of transactions in a block matching the given block
61    /// number.
62    #[method(name = "getBlockTransactionCountByNumber")]
63    async fn block_transaction_count_by_number(
64        &self, number: BlockNumberOrTag,
65    ) -> RpcResult<Option<U256>>;
66
67    /// Returns the number of uncles in a block from a block matching the given
68    /// block hash.
69    #[method(name = "getUncleCountByBlockHash")]
70    async fn block_uncles_count_by_hash(
71        &self, hash: H256,
72    ) -> RpcResult<Option<U256>>;
73
74    /// Returns the number of uncles in a block with given block number.
75    #[method(name = "getUncleCountByBlockNumber")]
76    async fn block_uncles_count_by_number(
77        &self, number: BlockNumberOrTag,
78    ) -> RpcResult<Option<U256>>;
79
80    /// Returns all transaction receipts for a given block.
81    #[method(name = "getBlockReceipts")]
82    async fn block_receipts(
83        &self, block_id: BlockId,
84    ) -> RpcResult<Option<Vec<Receipt>>>;
85
86    /// Returns an uncle block of the given block and index.
87    #[method(name = "getUncleByBlockHashAndIndex")]
88    async fn uncle_by_block_hash_and_index(
89        &self, hash: H256, index: Index,
90    ) -> RpcResult<Option<Block>>;
91
92    /// Returns an uncle block of the given block and index.
93    #[method(name = "getUncleByBlockNumberAndIndex")]
94    async fn uncle_by_block_number_and_index(
95        &self, number: BlockNumberOrTag, index: Index,
96    ) -> RpcResult<Option<Block>>;
97
98    /// Returns the EIP-2718 encoded transaction if it exists.
99    ///
100    /// If this is a EIP-4844 transaction that is in the pool it will include
101    /// the sidecar.
102    #[method(name = "getRawTransactionByHash")]
103    async fn raw_transaction_by_hash(
104        &self, hash: H256,
105    ) -> RpcResult<Option<Bytes>>;
106
107    /// Returns the information about a transaction requested by transaction
108    /// hash.
109    #[method(name = "getTransactionByHash")]
110    async fn transaction_by_hash(
111        &self, hash: H256,
112    ) -> RpcResult<Option<Transaction>>;
113
114    /// Returns information about a raw transaction by block hash and
115    /// transaction index position.
116    #[method(name = "getRawTransactionByBlockHashAndIndex")]
117    async fn raw_transaction_by_block_hash_and_index(
118        &self, hash: H256, index: Index,
119    ) -> RpcResult<Option<Bytes>>;
120
121    /// Returns information about a transaction by block hash and transaction
122    /// index position.
123    #[method(name = "getTransactionByBlockHashAndIndex")]
124    async fn transaction_by_block_hash_and_index(
125        &self, hash: H256, index: Index,
126    ) -> RpcResult<Option<Transaction>>;
127
128    /// Returns information about a raw transaction by block number and
129    /// transaction index position.
130    #[method(name = "getRawTransactionByBlockNumberAndIndex")]
131    async fn raw_transaction_by_block_number_and_index(
132        &self, number: BlockNumberOrTag, index: Index,
133    ) -> RpcResult<Option<Bytes>>;
134
135    /// Returns information about a transaction by block number and transaction
136    /// index position.
137    #[method(name = "getTransactionByBlockNumberAndIndex")]
138    async fn transaction_by_block_number_and_index(
139        &self, number: BlockNumberOrTag, index: Index,
140    ) -> RpcResult<Option<Transaction>>;
141
142    /// Returns information about a transaction by sender and nonce.
143    #[method(name = "getTransactionBySenderAndNonce")]
144    async fn transaction_by_sender_and_nonce(
145        &self, address: Address, nonce: U64,
146    ) -> RpcResult<Option<Transaction>>;
147
148    /// Returns the receipt of a transaction by transaction hash.
149    #[method(name = "getTransactionReceipt")]
150    async fn transaction_receipt(
151        &self, hash: H256,
152    ) -> RpcResult<Option<Receipt>>;
153
154    /// Returns the balance of the account of given address.
155    #[method(name = "getBalance")]
156    async fn balance(
157        &self, address: Address, block_number: Option<BlockId>,
158    ) -> RpcResult<U256>;
159
160    /// Returns the value from a storage position at a given address
161    #[method(name = "getStorageAt")]
162    async fn storage_at(
163        &self, address: Address, index: JsonStorageKey,
164        block_number: Option<BlockId>,
165    ) -> RpcResult<H256>;
166
167    /// Returns the number of transactions sent from an address at given block
168    /// number.
169    #[method(name = "getTransactionCount")]
170    async fn transaction_count(
171        &self, address: Address, block_number: Option<BlockId>,
172    ) -> RpcResult<U256>;
173
174    /// Returns code at a given address at given block number.
175    #[method(name = "getCode")]
176    async fn get_code(
177        &self, address: Address, block_number: Option<BlockId>,
178    ) -> RpcResult<Bytes>;
179
180    /// Returns the block's header at given number.
181    #[method(name = "getHeaderByNumber")]
182    async fn header_by_number(
183        &self, hash: BlockNumberOrTag,
184    ) -> RpcResult<Option<Header>>;
185
186    /// Returns the block's header at given hash.
187    #[method(name = "getHeaderByHash")]
188    async fn header_by_hash(&self, hash: H256) -> RpcResult<Option<Header>>;
189
190    /// `eth_simulateV1` executes an arbitrary number of transactions on top of
191    /// the requested state. The transactions are packed into individual
192    /// blocks. Overrides can be provided.
193    #[method(name = "simulateV1")]
194    async fn simulate_v1(
195        &self, opts: SimulatePayload, block_number: Option<BlockId>,
196    ) -> RpcResult<Vec<SimulatedBlock>>;
197
198    /// Executes a new message call immediately without creating a transaction
199    /// on the block chain.
200    #[method(name = "call")]
201    async fn call(
202        &self, request: TransactionRequest, block_number: Option<BlockId>,
203        state_overrides: Option<RpcStateOverride>,
204        block_overrides: Option<Box<BlockOverrides>>,
205    ) -> RpcResult<Bytes>;
206
207    /// Simulate arbitrary number of transactions at an arbitrary blockchain
208    /// index, with the optionality of state overrides
209    #[method(name = "callMany")]
210    async fn call_many(
211        &self, bundle: Bundle, state_context: Option<StateContext>,
212        state_override: Option<RpcStateOverride>,
213    ) -> RpcResult<Vec<EthCallResponse>>;
214
215    /// Generates an access list for a transaction.
216    ///
217    /// This method creates an [EIP2930](https://eips.ethereum.org/EIPS/eip-2930) type accessList based on a given Transaction.
218    ///
219    /// An access list contains all storage slots and addresses touched by the
220    /// transaction, except for the sender account and the chain's
221    /// precompiles.
222    ///
223    /// It returns list of addresses and storage keys used by the transaction,
224    /// plus the gas consumed when the access list is added. That is, it
225    /// gives you the list of addresses and storage keys that will be used
226    /// by that transaction, plus the gas consumed if the access
227    /// list is included. Like eth_estimateGas, this is an estimation; the list
228    /// could change when the transaction is actually mined. Adding an
229    /// accessList to your transaction does not necessary result in lower
230    /// gas usage compared to a transaction without an access list.
231    #[method(name = "createAccessList")]
232    async fn create_access_list(
233        &self, request: TransactionRequest, block_number: Option<BlockId>,
234        state_override: Option<RpcStateOverride>,
235    ) -> RpcResult<AccessListResult>;
236
237    /// Generates and returns an estimate of how much gas is necessary to allow
238    /// the transaction to complete.
239    #[method(name = "estimateGas")]
240    async fn estimate_gas(
241        &self, request: TransactionRequest, block_number: Option<BlockId>,
242        state_override: Option<RpcStateOverride>,
243    ) -> RpcResult<U256>;
244
245    /// Returns the current price per gas in wei.
246    #[method(name = "gasPrice")]
247    async fn gas_price(&self) -> RpcResult<U256>;
248
249    /// Returns the account details by specifying an address and a block
250    /// number/tag
251    // #[method(name = "getAccount")]
252    // async fn get_account(
253    //     &self,
254    //     address: Address,
255    //     block: BlockId,
256    // ) -> RpcResult<Option<reth_rpc_types::Account>>;
257
258    /// Introduced in EIP-1559, returns suggestion for the priority for dynamic
259    /// fee transactions.
260    #[method(name = "maxPriorityFeePerGas")]
261    async fn max_priority_fee_per_gas(&self) -> RpcResult<U256>;
262
263    /// Introduced in EIP-4844, returns the current blob base fee in wei.
264    // #[method(name = "blobBaseFee")]
265    // async fn blob_base_fee(&self) -> RpcResult<U256>;
266
267    /// Returns the Transaction fee history
268    ///
269    /// Introduced in EIP-1559 for getting information on the appropriate
270    /// priority fee to use.
271    ///
272    /// Returns transaction base fee per gas and effective priority fee per gas
273    /// for the requested/supported block range. The returned Fee history
274    /// for the returned block range can be a subsection of the requested
275    /// range if not all blocks are available.
276    #[method(name = "feeHistory")]
277    async fn fee_history(
278        &self, block_count: U64, newest_block: BlockNumberOrTag,
279        reward_percentiles: Option<Vec<f64>>,
280    ) -> RpcResult<FeeHistory>;
281
282    /// Returns whether the client is actively mining new blocks.
283    #[method(name = "mining")]
284    async fn is_mining(&self) -> RpcResult<bool>;
285
286    /// Returns the number of hashes per second that the node is mining with.
287    #[method(name = "hashrate")]
288    async fn hashrate(&self) -> RpcResult<U256>;
289
290    /// Returns the hash of the current block, the seedHash, and the boundary
291    /// condition to be met (“target”)
292    // #[method(name = "getWork")]
293    // async fn get_work(&self) -> RpcResult<Work>;
294
295    /// Used for submitting mining hashrate.
296    ///
297    /// Can be used for remote miners to submit their hash rate.
298    /// It accepts the miner hash rate and an identifier which must be unique
299    /// between nodes. Returns `true` if the block was successfully
300    /// submitted, `false` otherwise.
301    #[method(name = "submitHashrate")]
302    async fn submit_hashrate(
303        &self, hashrate: U256, id: H256,
304    ) -> RpcResult<bool>;
305
306    /// Used for submitting a proof-of-work solution.
307    #[method(name = "submitWork")]
308    async fn submit_work(
309        &self, nonce: H64, pow_hash: H256, mix_digest: H256,
310    ) -> RpcResult<bool>;
311
312    /// Sends transaction; will block waiting for signer to return the
313    /// transaction hash.
314    #[method(name = "sendTransaction")]
315    async fn send_transaction(
316        &self, request: TransactionRequest,
317    ) -> RpcResult<H256>;
318
319    /// Sends signed transaction, returning its hash.
320    #[method(name = "sendRawTransaction")]
321    async fn send_raw_transaction(&self, bytes: Bytes) -> RpcResult<H256>;
322
323    /// @alias of `eth_sendRawTransaction`.
324    #[method(name = "submitTransaction")]
325    async fn submit_transaction(&self, transaction: Bytes) -> RpcResult<H256>;
326
327    /// Returns an Ethereum specific signature with:
328    /// sign(keccak256("\x19Ethereum Signed Message:\n"
329    /// + len(message) + message))).
330    #[method(name = "sign")]
331    async fn sign(&self, address: Address, message: Bytes) -> RpcResult<Bytes>;
332
333    /// Signs a transaction that can be submitted to the network at a later time
334    /// using with `sendRawTransaction.`
335    #[method(name = "signTransaction")]
336    async fn sign_transaction(
337        &self, transaction: TransactionRequest,
338    ) -> RpcResult<Bytes>;
339
340    // Signs data via [EIP-712](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md).
341    // #[method(name = "signTypedData")]
342    // async fn sign_typed_data(&self, address: Address, data: TypedData) ->
343    // RpcResult<Bytes>;
344
345    // Returns the account and storage values of the specified account including
346    // the Merkle-proof. This call can be used to verify that the data you
347    // are pulling from is not tampered with.
348
349    // #[method(name = "getProof")]
350    // async fn get_proof(
351    //     &self,
352    //     address: Address,
353    //     keys: Vec<JsonStorageKey>,
354    //     block_number: Option<BlockId>,
355    // ) -> RpcResult<EIP1186AccountProofResponse>;
356
357    /// Returns logs matching given filter object.
358    #[method(name = "getLogs")]
359    async fn logs(&self, filter: Filter) -> RpcResult<Vec<Log>>;
360
361    #[method(name = "getAccountPendingTransactions")]
362    async fn account_pending_transactions(
363        &self, address: Address, maybe_start_nonce: Option<U256>,
364        maybe_limit: Option<U64>,
365    ) -> RpcResult<AccountPendingTransactions>;
366}
cfx_rpc_eth_api/eth.rs

cfx_rpc_eth_api/
eth.rs
