anvil-polkadot: add eth_sendUnsignedTransaction rpc (#348)

* anvil-polkadot: add eth_sendUnsignedTransaction rpc

Signed-off-by: Iulian Barbu <iulian.barbu@parity.io>

* anvil-polkadot(tests): introduce a send unsigned tx

Signed-off-by: Iulian Barbu <iulian.barbu@parity.io>

---------

Signed-off-by: Iulian Barbu <iulian.barbu@parity.io>

Author: iulianbarbu

crates/anvil-polkadot/src/api_server/server.rs

@@ -177,7 +177,7 @@ impl ApiServer {
             }
             EthRequest::EthCall(call, block, _, _) => self.call(call, block).await.to_rpc_result(),
             EthRequest::EthSendTransaction(request) => {
-                self.send_transaction(*request.clone()).await.to_rpc_result()
+                self.send_transaction(*request.clone(), false).await.to_rpc_result()
             }
             EthRequest::EthGasPrice(()) => self.gas_price().await.to_rpc_result(),
             EthRequest::EthGetBlockByNumber(num, hydrated) => {
@@ -252,6 +252,10 @@ impl ApiServer {
                 node_info!("eth_getLogs");
                 self.get_logs(filter).await.to_rpc_result()
             }
+            EthRequest::EthSendUnsignedTransaction(request) => {
+                node_info!("eth_sendUnsignedTransaction");
+                self.send_transaction(*request.clone(), true).await.to_rpc_result()
+            }
             _ => Err::<(), _>(Error::RpcUnimplemented).to_rpc_result(),
         };
 
@@ -546,6 +550,7 @@ impl ApiServer {
     async fn send_transaction(
         &self,
         transaction_req: WithOtherFields<TransactionRequest>,
+        unsigned_tx: bool,
     ) -> Result<H256> {
         node_info!("eth_sendTransaction");
         let mut transaction = convert_to_generic_transaction(transaction_req.clone().into_inner());
@@ -576,7 +581,7 @@ impl ApiServer {
             .try_into_unsigned()
             .map_err(|_| Error::ReviveRpc(EthRpcError::InvalidTransaction))?;
 
-        let payload = if self.impersonation_manager.is_impersonated(from) {
+        let payload = if self.impersonation_manager.is_impersonated(from) || unsigned_tx {
             let mut fake_signature = [0; 65];
             fake_signature[12..32].copy_from_slice(from.as_bytes());
             tx.with_signature(fake_signature).signed_payload()

crates/anvil-polkadot/tests/it/impersonation.rs

@@ -183,3 +183,48 @@ async fn test_auto_impersonate(#[case] rpc_driven: bool) {
         format!("Account not found for address {}", dest_addr.to_string().to_lowercase()).as_str()
     ));
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_send_unsigned_tx() {
+    let anvil_node_config = AnvilNodeConfig::test_config();
+    let substrate_node_config = SubstrateNodeConfig::new(&anvil_node_config);
+    let mut node = TestNode::new(anvil_node_config.clone(), substrate_node_config).await.unwrap();
+
+    // Enable automine.
+    unwrap_response::<()>(node.eth_rpc(EthRequest::SetAutomine(true)).await.unwrap()).unwrap();
+
+    // Create a random account.
+    let alith_account = Account::from(subxt_signer::eth::dev::alith());
+    let alith_addr = Address::from(ReviveAddress::new(alith_account.address()));
+    let transfer_amount = U256::from(16e17);
+    let dest_addr =
+        transfer_to_unitialized_random_account(&mut node, alith_addr, transfer_amount).await;
+    let dest_h160 = H160::from_slice(dest_addr.as_slice());
+
+    // Impersonate destination
+    let transfer_amount = U256::from(1e11);
+    let alith_balance = node.get_balance(alith_account.address(), None).await;
+    let dest_balance = node.get_balance(dest_h160, None).await;
+    let transaction =
+        TransactionRequest::default().value(transfer_amount).from(dest_addr).to(alith_addr);
+    let tx_hash = node
+        .send_unsigned_transaction(
+            transaction,
+            Some(BlockWaitTimeout::new(2, Duration::from_secs(1))),
+        )
+        .await
+        .unwrap();
+    tokio::time::sleep(std::time::Duration::from_millis(500)).await;
+    let receipt_info = node.get_transaction_receipt(tx_hash).await;
+
+    // Assert on balances after second transfer.
+    let alith_final_balance = node.get_balance(alith_account.address(), None).await;
+    let dest_final_balance = node.get_balance(dest_h160, None).await;
+    assert_eq!(alith_final_balance, alith_balance + transfer_amount);
+    assert_eq!(
+        dest_final_balance,
+        dest_balance
+            - transfer_amount
+            - AlloyU256::from(receipt_info.effective_gas_price * receipt_info.gas_used).inner()
+    );
+}

crates/anvil-polkadot/tests/it/utils.rs

@@ -120,13 +120,41 @@ impl TestNode {
         transaction: TransactionRequest,
         timeout: Option<BlockWaitTimeout>,
     ) -> Result<H256, RpcError> {
-        let tx_hash = unwrap_response::<H256>(
-            self.eth_rpc(EthRequest::EthSendTransaction(Box::new(WithOtherFields::new(
-                transaction,
-            ))))
-            .await
-            .unwrap(),
-        )?;
+        self.send_transaction_inner(transaction, timeout, false).await
+    }
+
+    /// Execute an impersonated ethereum transaction.
+    pub async fn send_unsigned_transaction(
+        &mut self,
+        transaction: TransactionRequest,
+        timeout: Option<BlockWaitTimeout>,
+    ) -> Result<H256, RpcError> {
+        self.send_transaction_inner(transaction, timeout, true).await
+    }
+
+    async fn send_transaction_inner(
+        &mut self,
+        transaction: TransactionRequest,
+        timeout: Option<BlockWaitTimeout>,
+        unsigned: bool,
+    ) -> Result<H256, RpcError> {
+        let tx_hash = if unsigned {
+            unwrap_response::<H256>(
+                self.eth_rpc(EthRequest::EthSendUnsignedTransaction(Box::new(
+                    WithOtherFields::new(transaction),
+                )))
+                .await
+                .unwrap(),
+            )?
+        } else {
+            unwrap_response::<H256>(
+                self.eth_rpc(EthRequest::EthSendTransaction(Box::new(WithOtherFields::new(
+                    transaction,
+                ))))
+                .await
+                .unwrap(),
+            )?
+        };
 
         if let Some(BlockWaitTimeout { block_number, timeout }) = timeout {
             self.wait_for_block_with_timeout(block_number, timeout).await.unwrap();