feat: add eth_sendRawTransaction client support

evm_rpc_client/src/lib.rs

@@ -110,12 +110,13 @@ mod runtime;
 use crate::request::{
     CallRequest, CallRequestBuilder, FeeHistoryRequest, FeeHistoryRequestBuilder,
     GetBlockByNumberRequest, GetBlockByNumberRequestBuilder, GetTransactionCountRequest,
-    GetTransactionCountRequestBuilder, Request, RequestBuilder,
+    GetTransactionCountRequestBuilder, Request, RequestBuilder, SendRawTransactionRequest,
+    SendRawTransactionRequestBuilder,
 };
 use candid::{CandidType, Principal};
 use evm_rpc_types::{
     BlockTag, CallArgs, ConsensusStrategy, FeeHistoryArgs, GetLogsArgs, GetTransactionCountArgs,
-    RpcConfig, RpcServices,
+    Hex, RpcConfig, RpcServices,
 };
 use ic_error_types::RejectCode;
 use request::{GetLogsRequest, GetLogsRequestBuilder};
@@ -553,6 +554,43 @@ impl<R> EvmRpcClient<R> {
             10_000_000_000,
         )
     }
+
+    /// Call `eth_sendRawTransaction` on the EVM RPC canister.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use alloy_primitives::{b256, bytes};
+    /// use evm_rpc_client::EvmRpcClient;
+    ///
+    /// # use evm_rpc_types::{MultiRpcResult, Hex32, SendRawTransactionStatus};
+    /// # use std::str::FromStr;
+    /// # #[tokio::main]
+    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /// let client = EvmRpcClient::builder_for_ic()
+    /// #   .with_default_stub_response(MultiRpcResult::Consistent(Ok(SendRawTransactionStatus::Ok(Some(Hex32::from_str("0x33469b22e9f636356c4160a87eb19df52b7412e8eac32a4a55ffe88ea8350788").unwrap())))))
+    ///     .build();
+    ///
+    /// let result = client
+    ///     .send_raw_transaction(bytes!("0xf86c098504a817c800825208943535353535353535353535353535353535353535880de0b6b3a76400008025a028ef61340bd939bc2195fe537567866003e1a15d3c71ff63e1590620aa636276a067cbe9d8997f761aecb703304b3800ccf555c9f3dc64214b297fb1966a3b6d83"))
+    ///     .send()
+    ///     .await
+    ///     .expect_consistent();
+    ///
+    /// assert_eq!(result, Ok(b256!("0x33469b22e9f636356c4160a87eb19df52b7412e8eac32a4a55ffe88ea8350788")));
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn send_raw_transaction(
+        &self,
+        params: impl Into<Hex>,
+    ) -> SendRawTransactionRequestBuilder<R> {
+        RequestBuilder::new(
+            self.clone(),
+            SendRawTransactionRequest::new(params.into()),
+            10_000_000_000,
+        )
+    }
 }
 
 impl<R: Runtime> EvmRpcClient<R> {

evm_rpc_client/src/request/mod.rs

@@ -242,6 +242,38 @@ impl<R> GetTransactionCountRequestBuilder<R> {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct SendRawTransactionRequest(Hex);
+
+impl SendRawTransactionRequest {
+    pub fn new(params: Hex) -> Self {
+        Self(params)
+    }
+}
+
+impl EvmRpcRequest for SendRawTransactionRequest {
+    type Config = RpcConfig;
+    type Params = Hex;
+    type CandidOutput = MultiRpcResult<evm_rpc_types::SendRawTransactionStatus>;
+    type Output = MultiRpcResult<alloy_primitives::B256>;
+
+    fn endpoint(&self) -> EvmRpcEndpoint {
+        EvmRpcEndpoint::SendRawTransaction
+    }
+
+    fn params(self) -> Self::Params {
+        self.0
+    }
+}
+
+pub type SendRawTransactionRequestBuilder<R> = RequestBuilder<
+    R,
+    RpcConfig,
+    Hex,
+    MultiRpcResult<evm_rpc_types::SendRawTransactionStatus>,
+    MultiRpcResult<alloy_primitives::B256>,
+>;
+
 /// Ethereum RPC endpoint supported by the EVM RPC canister.
 pub trait EvmRpcRequest {
     /// Type of RPC config for that request.
@@ -273,6 +305,8 @@ pub enum EvmRpcEndpoint {
     GetLogs,
     /// `eth_getTransactionCount` endpoint.
     GetTransactionCount,
+    /// `eth_sendRawTransaction` endpoint.
+    SendRawTransaction,
 }
 
 impl EvmRpcEndpoint {
@@ -284,6 +318,7 @@ impl EvmRpcEndpoint {
             Self::GetBlockByNumber => "eth_getBlockByNumber",
             Self::GetLogs => "eth_getLogs",
             Self::GetTransactionCount => "eth_getTransactionCount",
+            Self::SendRawTransaction => "eth_sendRawTransaction",
         }
     }
 }

evm_rpc_types/src/result/alloy.rs

@@ -1,4 +1,7 @@
-use crate::{Block, FeeHistory, Hex, LogEntry, MultiRpcResult, Nat256};
+use crate::{
+    Block, FeeHistory, Hex, JsonRpcError, LogEntry, MultiRpcResult, Nat256, RpcError,
+    SendRawTransactionStatus, ValidationError,
+};
 
 impl From<MultiRpcResult<Vec<LogEntry>>> for MultiRpcResult<Vec<alloy_rpc_types::Log>> {
     fn from(result: MultiRpcResult<Vec<LogEntry>>) -> Self {
@@ -33,3 +36,26 @@ impl From<MultiRpcResult<Hex>> for MultiRpcResult<alloy_primitives::Bytes> {
         result.map(alloy_primitives::Bytes::from)
     }
 }
+
+impl From<MultiRpcResult<SendRawTransactionStatus>> for MultiRpcResult<alloy_primitives::B256> {
+    fn from(result: MultiRpcResult<SendRawTransactionStatus>) -> Self {
+        result.and_then(|status| match status {
+            SendRawTransactionStatus::Ok(maybe_hash) => match maybe_hash {
+                Some(hash) => Ok(alloy_primitives::B256::from(hash)),
+                None => Err(RpcError::ValidationError(ValidationError::Custom(
+                    "Unable to compute transaction hash".to_string(),
+                ))),
+            },
+            error => Err(RpcError::JsonRpcError(JsonRpcError {
+                code: -32_000,
+                message: match error {
+                    SendRawTransactionStatus::Ok(_) => unreachable!(),
+                    SendRawTransactionStatus::InsufficientFunds => "Insufficient funds",
+                    SendRawTransactionStatus::NonceTooLow => "Nonce too low",
+                    SendRawTransactionStatus::NonceTooHigh => "Nonce too high",
+                }
+                .to_string(),
+            })),
+        })
+    }
+}