fix getStorage and setStorage RPCs (#385)

- getStorage should return empty data for an inexistent account (we were previously returning error)
- setStorage should also work for inexistent accounts or EOAs

Author: alindima

.github/workflows/test.yml

@@ -53,19 +53,19 @@ jobs:
           force_orphan: true
 
   doctest:
-    runs-on: ubuntu-latest
+    runs-on: parity-large-new
     timeout-minutes: 60
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/[email protected]
+      - name: Install build tools
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y clang libclang-dev unzip build-essential
       - name: Install protobuf-compiler
         uses: arduino/setup-protoc@v3
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Install clang on ubuntu
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y clang libclang-dev
       - uses: dtolnay/[email protected]
         with:
           target: wasm32-unknown-unknown

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

@@ -564,13 +564,21 @@ impl ApiServer {
         addr: Address,
         slot: U256,
         block: Option<BlockId>,
-    ) -> Result<Bytes> {
+    ) -> Result<B256> {
         node_info!("eth_getStorageAt");
         let hash = self.get_block_hash_for_tag(block).await?;
         let runtime_api = self.eth_rpc_client.runtime_api(hash);
-        let bytes =
-            runtime_api.get_storage(ReviveAddress::from(addr).inner(), slot.to_be_bytes()).await?;
-        Ok(bytes.unwrap_or_default().into())
+        let bytes: B256 = match runtime_api
+            .get_storage(ReviveAddress::from(addr).inner(), slot.to_be_bytes())
+            .await
+        {
+            Ok(Some(bytes)) => bytes.as_slice().try_into().map_err(|_| {
+                Error::InternalError("Unable to convert value to 32-byte value".to_string())
+            })?,
+            Ok(None) | Err(ClientError::ContractNotFound) => Default::default(),
+            Err(err) => return Err(Error::ReviveRpc(EthRpcError::ClientError(err))),
+        };
+        Ok(bytes)
     }
 
     async fn get_code(&self, address: Address, block: Option<BlockId>) -> Result<Bytes> {
@@ -994,15 +1002,58 @@ impl ApiServer {
 
         let latest_block = self.latest_block();
 
-        let Some(ReviveAccountInfo { account_type: AccountType::Contract(contract_info), .. }) =
-            self.backend.read_revive_account_info(latest_block, address)?
-        else {
-            return Ok(());
+        let account_id = self.get_account_id(latest_block, address)?;
+
+        let maybe_system_account_info =
+            self.backend.read_system_account_info(latest_block, account_id.clone())?;
+        let nonce = maybe_system_account_info.as_ref().map(|info| info.nonce).unwrap_or_default();
+
+        if maybe_system_account_info.is_none() {
+            self.set_frame_system_balance(
+                latest_block,
+                account_id,
+                substrate_runtime::currency::DOLLARS,
+            )?;
+        }
+
+        let trie_id = match self.backend.read_revive_account_info(latest_block, address)? {
+            // If the account doesn't exist, create one.
+            None => {
+                let contract_info = new_contract_info(&address, (*KECCAK_EMPTY).into(), nonce);
+                let trie_id = contract_info.trie_id.clone();
+
+                self.backend.inject_revive_account_info(
+                    latest_block,
+                    address,
+                    ReviveAccountInfo {
+                        account_type: AccountType::Contract(contract_info),
+                        dust: 0,
+                    },
+                );
+
+                trie_id
+            }
+            // If the account is not already a contract account, make it one.
+            Some(ReviveAccountInfo { account_type: AccountType::EOA, dust }) => {
+                let contract_info = new_contract_info(&address, (*KECCAK_EMPTY).into(), nonce);
+                let trie_id = contract_info.trie_id.clone();
+
+                self.backend.inject_revive_account_info(
+                    latest_block,
+                    address,
+                    ReviveAccountInfo { account_type: AccountType::Contract(contract_info), dust },
+                );
+
+                trie_id
+            }
+            Some(ReviveAccountInfo {
+                account_type: AccountType::Contract(contract_info), ..
+            }) => contract_info.trie_id,
         };
 
         self.backend.inject_child_storage(
             latest_block,
-            contract_info.trie_id.to_vec(),
+            trie_id.to_vec(),
             key.to_be_bytes_vec(),
             value.to_vec(),
         );

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

@@ -599,6 +599,16 @@ async fn test_get_storage() {
     unwrap_response::<()>(node.eth_rpc(EthRequest::SetAutomine(true)).await.unwrap()).unwrap();
     let alith = Account::from(subxt_signer::eth::dev::alith());
 
+    // Test retrieving the storage of an EOA account (alith)
+    let stored_value = node.get_storage_at(U256::from(0), alith.address()).await;
+    assert_eq!(stored_value, 0);
+
+    // Test retrieving the storage of a non-existant account.
+    let random_addr = Address::random();
+    let stored_value =
+        node.get_storage_at(U256::from(0), ReviveAddress::from(random_addr).inner()).await;
+    assert_eq!(stored_value, 0);
+
     let contract_code = get_contract_code("SimpleStorage");
     let tx_hash = node.deploy_contract(&contract_code.init, alith.address(), Some(1)).await;
     tokio::time::sleep(Duration::from_millis(400)).await;

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

@@ -595,51 +595,81 @@ async fn test_set_storage() {
     let mut node = TestNode::new(anvil_node_config.clone(), substrate_node_config).await.unwrap();
     let alith = Account::from(subxt_signer::eth::dev::alith());
 
-    let contract_code = get_contract_code("SimpleStorage");
-    let tx_hash = node.deploy_contract(&contract_code.init, alith.address(), None).await;
-    unwrap_response::<()>(node.eth_rpc(EthRequest::Mine(None, None)).await.unwrap()).unwrap();
-    tokio::time::sleep(std::time::Duration::from_millis(400)).await;
-    let receipt = node.get_transaction_receipt(tx_hash).await;
-    let contract_address = receipt.contract_address.unwrap();
-
-    // Check the default value for slot 0.
-    let result = node
-        .eth_rpc(EthRequest::EthGetStorageAt(
-            Address::from(ReviveAddress::new(contract_address)),
-            U256::from(0),
-            None,
-        ))
-        .await
+    // Set storage of a new random account.
+    {
+        let random_addr = Address::random();
+
+        let stored_value =
+            node.get_storage_at(U256::from(0), ReviveAddress::from(random_addr).inner()).await;
+        assert_eq!(stored_value, 0);
+
+        // Set a new value for the slot 0.
+        unwrap_response::<()>(
+            node.eth_rpc(EthRequest::SetStorageAt(
+                random_addr,
+                U256::from(0),
+                B256::from(U256::from(511)),
+            ))
+            .await
+            .unwrap(),
+        )
         .unwrap();
-    let hex_string = unwrap_response::<String>(result).unwrap();
-    let hex_value = hex_string.strip_prefix("0x").unwrap_or(&hex_string);
-    let stored_value = U256::from_str_radix(hex_value, 16).unwrap();
-    assert_eq!(stored_value, 0);
 
-    // Set a new value for the slot 0.
-
-    unwrap_response::<()>(
-        node.eth_rpc(EthRequest::SetStorageAt(
-            Address::from(ReviveAddress::new(contract_address)),
-            U256::from(0),
-            B256::from(U256::from(511)),
-        ))
-        .await
-        .unwrap(),
-    )
-    .unwrap();
+        // Check that the value was updated
+        let stored_value =
+            node.get_storage_at(U256::from(0), ReviveAddress::from(random_addr).inner()).await;
+        assert_eq!(stored_value, 511);
+    }
+
+    // Update the storage of an existing account
+    {
+        let contract_code = get_contract_code("SimpleStorage");
+        let tx_hash = node.deploy_contract(&contract_code.init, alith.address(), None).await;
+        unwrap_response::<()>(node.eth_rpc(EthRequest::Mine(None, None)).await.unwrap()).unwrap();
+        tokio::time::sleep(std::time::Duration::from_millis(400)).await;
+        let receipt = node.get_transaction_receipt(tx_hash).await;
+        let contract_address = receipt.contract_address.unwrap();
+
+        // Check the default value for slot 0.
+        let stored_value = node.get_storage_at(U256::from(0), contract_address).await;
+        assert_eq!(stored_value, 0);
+
+        // Set a new value for the slot 0.
+        unwrap_response::<()>(
+            node.eth_rpc(EthRequest::SetStorageAt(
+                Address::from(ReviveAddress::new(contract_address)),
+                U256::from(0),
+                B256::from(U256::from(511)),
+            ))
+            .await
+            .unwrap(),
+        )
+        .unwrap();
 
-    // Check that the value was updated
-    let result = node
-        .eth_rpc(EthRequest::EthGetStorageAt(
-            Address::from(ReviveAddress::new(contract_address)),
-            U256::from(0),
-            None,
-        ))
-        .await
+        // Check that the value was updated
+        let stored_value = node.get_storage_at(U256::from(0), contract_address).await;
+        assert_eq!(stored_value, 511);
+    }
+
+    // Set storage for a EOA account (Alith).
+    {
+        let stored_value = node.get_storage_at(U256::from(0), alith.address()).await;
+        assert_eq!(stored_value, 0);
+
+        // Set a new value for the slot 0.
+        unwrap_response::<()>(
+            node.eth_rpc(EthRequest::SetStorageAt(
+                Address::from(ReviveAddress::new(alith.address())),
+                U256::from(0),
+                B256::from(U256::from(511)),
+            ))
+            .await
+            .unwrap(),
+        )
         .unwrap();
-    let hex_string = unwrap_response::<String>(result).unwrap();
-    let hex_value = hex_string.strip_prefix("0x").unwrap_or(&hex_string);
-    let stored_value = U256::from_str_radix(hex_value, 16).unwrap();
-    assert_eq!(stored_value, 511);
+
+        // Check that the value was updated
+        let stored_value = node.get_storage_at(U256::from(0), alith.address()).await;
+        assert_eq!(stored_value, 511);
+    }
 }

crates/script/src/progress.rs

@@ -171,7 +171,7 @@ impl ScriptProgress {
         progress
     }
 
-    /// Traverses a set of pendings and either finds receipts, or clears them from
+    /// Traverses a set of pending transactions and either finds receipts, or clears them from
     /// the deployment sequence.
     ///
     /// For each `tx_hash`, we check if it has confirmed. If it has