feat: add rpc endpoint eth_getCode

crates/rpc/src/eth/account.rs

@@ -12,6 +12,11 @@ pub struct GetBalanceRequest {
     pub block: BlockIdentifier,
 }
 
+pub struct GetCodeRequest {
+    pub address: Address,
+    pub block: BlockIdentifier,
+}
+
 impl GetBalanceRequest {
     pub fn parse(params: &Option<Vec<Value>>) -> Option<GetBalanceRequest> {
         let params = params.as_ref()?;
@@ -25,6 +30,19 @@ impl GetBalanceRequest {
     }
 }
 
+impl GetCodeRequest {
+    pub fn parse(params: &Option<Vec<Value>>) -> Option<GetCodeRequest> {
+        let params = params.as_ref()?;
+        if params.len() != 2 {
+            return None;
+        };
+        Some(GetCodeRequest {
+            address: serde_json::from_value(params[0].clone()).ok()?,
+            block: serde_json::from_value(params[1].clone()).ok()?,
+        })
+    }
+}
+
 pub fn get_balance(request: &GetBalanceRequest, storage: Store) -> Result<Value, RpcErr> {
     info!(
         "Requested balance of account {} at block {}",
@@ -40,3 +58,19 @@ pub fn get_balance(request: &GetBalanceRequest, storage: Store) -> Result<Value,
 
     serde_json::to_value(format!("{:#x}", account.balance)).map_err(|_| RpcErr::Internal)
 }
+
+pub fn get_code(request: &GetCodeRequest, storage: Store) -> Result<Value, RpcErr> {
+    info!(
+        "Requested code of account {} at block {}",
+        request.address, request.block
+    );
+    let code = match storage.get_code_by_account_address(request.address) {
+        Ok(Some(code)) => code,
+        // Account not found
+        Ok(_) => return Ok(Value::Null),
+        // DB error
+        _ => return Err(RpcErr::Internal),
+    };
+
+    serde_json::to_value(format!("0x{:x}", code)).map_err(|_| RpcErr::Internal)
+}

crates/rpc/src/lib.rs

@@ -3,7 +3,7 @@ use std::{future::IntoFuture, net::SocketAddr};
 use axum::{routing::post, Json, Router};
 use engine::{ExchangeCapabilitiesRequest, NewPayloadV3Request};
 use eth::{
-    account::{self, GetBalanceRequest},
+    account::{self, GetBalanceRequest, GetCodeRequest},
     block::{
         self, GetBlockByHashRequest, GetBlockByNumberRequest,
         GetBlockTransactionCountByNumberRequest, GetTransactionByBlockHashAndIndexRequest,
@@ -97,6 +97,10 @@ pub fn map_requests(req: &RpcRequest, storage: Store) -> Result<Value, RpcErr> {
             let request = GetBalanceRequest::parse(&req.params).ok_or(RpcErr::BadParams)?;
             account::get_balance(&request, storage)
         }
+        "eth_getCode" => {
+            let request = GetCodeRequest::parse(&req.params).ok_or(RpcErr::BadParams)?;
+            account::get_code(&request, storage)
+        }
         "eth_getBlockTransactionCountByNumber" => {
             let request = GetBlockTransactionCountByNumberRequest::parse(&req.params)
                 .ok_or(RpcErr::BadParams)?;

crates/storage/src/in_memory.rs

@@ -1,7 +1,8 @@
 use super::{Key, StoreEngine, Value};
 use crate::error::StoreError;
+use bytes::Bytes;
 use ethereum_rust_core::types::{AccountInfo, BlockBody, BlockHash, BlockHeader, BlockNumber};
-use ethereum_types::Address;
+use ethereum_types::{Address, H256};
 use std::{collections::HashMap, fmt::Debug};
 
 #[derive(Default)]
@@ -11,6 +12,8 @@ pub struct Store {
     bodies: HashMap<BlockNumber, BlockBody>,
     headers: HashMap<BlockNumber, BlockHeader>,
     values: HashMap<Key, Value>,
+    // Maps code hashes to code
+    account_codes: HashMap<H256, Bytes>,
 }
 
 impl Store {
@@ -80,6 +83,15 @@ impl StoreEngine for Store {
     fn get_block_number(&self, block_hash: BlockHash) -> Result<Option<BlockNumber>, StoreError> {
         Ok(self.block_numbers.get(&block_hash).copied())
     }
+
+    fn add_account_code(&mut self, code_hash: H256, code: Bytes) -> Result<(), StoreError> {
+        self.account_codes.insert(code_hash, code);
+        Ok(())
+    }
+
+    fn get_account_code(&self, code_hash: H256) -> Result<Option<Bytes>, StoreError> {
+        Ok(self.account_codes.get(&code_hash).cloned())
+    }
 }
 
 impl Debug for Store {

crates/storage/src/lib.rs

@@ -13,8 +13,9 @@ use self::libmdbx::Store as LibmdbxStore;
 use self::rocksdb::Store as RocksDbStore;
 #[cfg(feature = "sled")]
 use self::sled::Store as SledStore;
+use bytes::Bytes;
 use ethereum_rust_core::types::{AccountInfo, BlockBody, BlockHash, BlockHeader, BlockNumber};
-use ethereum_types::Address;
+use ethereum_types::{Address, H256};
 use std::fmt::Debug;
 use std::sync::{Arc, Mutex};
 
@@ -82,6 +83,22 @@ pub trait StoreEngine: Debug + Send {
 
     /// Retrieve a stored value under Key
     fn get_value(&self, key: Key) -> Result<Option<Value>, StoreError>;
+
+    /// Add account code
+    fn add_account_code(&mut self, code_hash: H256, code: Bytes) -> Result<(), StoreError>;
+
+    /// Obtain account code via code hash
+    fn get_account_code(&self, code_hash: H256) -> Result<Option<Bytes>, StoreError>;
+
+    /// Obtain account code via account address
+    fn get_code_by_account_address(&self, address: Address) -> Result<Option<Bytes>, StoreError> {
+        let code_hash = match self.get_account_info(address) {
+            Ok(Some(acc_info)) => acc_info.code_hash,
+            Ok(None) => return Ok(None),
+            Err(error) => return Err(error),
+        };
+        self.get_account_code(code_hash)
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -212,6 +229,33 @@ impl Store {
             .unwrap()
             .get_block_number(block_hash)
     }
+
+    pub fn add_account_code(&self, code_hash: H256, code: Bytes) -> Result<(), StoreError> {
+        self.engine
+            .clone()
+            .lock()
+            .unwrap()
+            .add_account_code(code_hash, code)
+    }
+
+    pub fn get_account_code(&self, code_hash: H256) -> Result<Option<Bytes>, StoreError> {
+        self.engine
+            .clone()
+            .lock()
+            .unwrap()
+            .get_account_code(code_hash)
+    }
+
+    pub fn get_code_by_account_address(
+        &self,
+        address: Address,
+    ) -> Result<Option<Bytes>, StoreError> {
+        self.engine
+            .clone()
+            .lock()
+            .unwrap()
+            .get_code_by_account_address(address)
+    }
 }
 
 #[cfg(test)]
@@ -269,6 +313,7 @@ mod tests {
         test_store_account(store.clone());
         test_store_block(store.clone());
         test_store_block_number(store.clone());
+        test_store_account_code(store.clone());
     }
 
     fn test_store_account(mut store: Store) {
@@ -390,4 +435,15 @@ mod tests {
 
         assert_eq!(stored_number, block_number);
     }
+
+    fn test_store_account_code(store: Store) {
+        let code_hash = H256::random();
+        let code = Bytes::from("kiwi");
+
+        store.add_account_code(code_hash, code.clone()).unwrap();
+
+        let stored_code = store.get_account_code(code_hash).unwrap().unwrap();
+
+        assert_eq!(stored_code, code);
+    }
 }

crates/storage/src/libmdbx.rs

@@ -5,9 +5,10 @@ use crate::rlp::{
     AccountStorageValueRLP, AddressRLP, BlockBodyRLP, BlockHashRLP, BlockHeaderRLP, ReceiptRLP,
 };
 use anyhow::Result;
+use bytes::Bytes;
 use ethereum_rust_core::types::{AccountInfo, BlockBody, BlockHash, BlockHeader};
 use ethereum_rust_core::types::{BlockNumber, Index};
-use ethereum_types::Address;
+use ethereum_types::{Address, H256};
 use libmdbx::{
     dupsort,
     orm::{table, Database},
@@ -139,6 +140,26 @@ impl StoreEngine for Store {
     fn get_value(&self, _key: Key) -> Result<Option<Value>, StoreError> {
         todo!()
     }
+
+    fn add_account_code(&mut self, code_hash: H256, code: Bytes) -> Result<(), StoreError> {
+        // Write account code to mdbx
+        let txn = self
+            .db
+            .begin_readwrite()
+            .map_err(StoreError::LibmdbxError)?;
+        txn.upsert::<AccountCodes>(code_hash.into(), code.into())
+            .map_err(StoreError::LibmdbxError)?;
+        txn.commit().map_err(StoreError::LibmdbxError)
+    }
+
+    fn get_account_code(&self, code_hash: H256) -> Result<Option<Bytes>, StoreError> {
+        // Read account code from mdbx
+        let txn = self.db.begin_read().map_err(StoreError::LibmdbxError)?;
+        Ok(txn
+            .get::<AccountCodes>(code_hash.into())
+            .map_err(StoreError::LibmdbxError)?
+            .map(|b| b.to()))
+    }
 }
 
 impl Debug for Store {

crates/storage/src/rlp.rs

@@ -1,17 +1,18 @@
 use std::marker::PhantomData;
 
+use bytes::Bytes;
 use ethereum_rust_core::{
     rlp::{decode::RLPDecode, encode::RLPEncode},
     types::{AccountInfo, BlockBody, BlockHash, BlockHeader, Receipt},
-    Address,
+    Address, H256,
 };
 use libmdbx::orm::{Decodable, Encodable};
 
 // Account types
 pub type AddressRLP = Rlp<Address>;
 pub type AccountInfoRLP = Rlp<AccountInfo>;
-pub type AccountCodeHashRLP = Rlp<Vec<u8>>;
-pub type AccountCodeRLP = Rlp<Vec<u8>>;
+pub type AccountCodeHashRLP = Rlp<H256>;
+pub type AccountCodeRLP = Rlp<Bytes>;
 
 // TODO: these structs were changed after a merge.
 // See if we can reuse Rlp struct

crates/storage/src/rocksdb.rs

@@ -1,8 +1,9 @@
 use super::{Key, StoreEngine, Value};
 use crate::error::StoreError;
 use crate::rlp::{AccountInfoRLP, AddressRLP};
+use bytes::Bytes;
 use ethereum_rust_core::types::{AccountInfo, BlockBody, BlockHash, BlockHeader, BlockNumber};
-use ethereum_types::Address;
+use ethereum_types::{Address, H256};
 use libmdbx::orm::{Decodable, Encodable};
 use std::fmt::Debug;
 use std::sync::mpsc::{channel, sync_channel, Receiver, Sender, SyncSender};
@@ -165,6 +166,14 @@ impl StoreEngine for Store {
 
         reply_receiver.recv()?
     }
+
+    fn add_account_code(&mut self, _code_hash: H256, _code: Bytes) -> Result<(), StoreError> {
+        todo!()
+    }
+
+    fn get_account_code(&self, _code_hash: H256) -> Result<Option<Bytes>, StoreError> {
+        todo!()
+    }
 }
 
 impl Debug for Store {

crates/storage/src/sled.rs

@@ -1,8 +1,9 @@
 use super::{Key, StoreEngine, Value};
 use crate::error::StoreError;
 use crate::rlp::{AccountInfoRLP, AddressRLP};
+use bytes::Bytes;
 use ethereum_rust_core::types::{AccountInfo, BlockBody, BlockHash, BlockHeader, BlockNumber};
-use ethereum_types::Address;
+use ethereum_types::{Address, H256};
 use libmdbx::orm::{Decodable, Encodable};
 use sled::Db;
 use std::fmt::Debug;
@@ -93,6 +94,14 @@ impl StoreEngine for Store {
     fn get_value(&self, key: Key) -> Result<Option<Vec<u8>>, StoreError> {
         Ok(self.values.get(key)?.map(|value| value.to_vec()))
     }
+
+    fn add_account_code(&mut self, _code_hash: H256, _code: Bytes) -> Result<(), StoreError> {
+        todo!()
+    }
+
+    fn get_account_code(&self, _code_hash: H256) -> Result<Option<Bytes>, StoreError> {
+        todo!()
+    }
 }
 
 impl Debug for Store {