state coverage and fix

Author: oXtxNt9U

packages/evm/core/src/state_changes.rs

@@ -37,7 +37,7 @@ pub struct StorageChangeset {
     pub storage: Vec<(U256, StorageSlot)>,
 }
 
-#[derive(Default, Debug)]
+#[derive(Default, Debug, PartialEq, Eq)]
 pub struct AccountUpdate {
     pub address: Address,
     pub balance: U256,
@@ -54,7 +54,7 @@ pub struct AccountUpdate {
     pub merge_info: Option<AccountMergeInfo>,
 }
 
-#[derive(Default, Debug)]
+#[derive(Default, Debug, PartialEq, Eq)]
 pub struct AccountMergeInfo {
     pub legacy_address: LegacyAddress,
     pub transaction_hash: B256,

packages/evm/core/src/state_commit.rs

@@ -152,7 +152,7 @@ fn collect_dirty_accounts(
                                         Some(account)
                                     });
 
-                                    break;
+                                    continue;
                                 }
 
                                 // Attempt to decode the log as a Unvoted event
@@ -168,7 +168,7 @@ fn collect_dirty_accounts(
                                         Some(account)
                                     });
 
-                                    break;
+                                    continue;
                                 }
                             }
                             _ if log.address == info.username_contract => {
@@ -181,7 +181,7 @@ fn collect_dirty_accounts(
                                         account.username_resigned = false; // cancel out any previous resignation if one happened in same commit
                                         Some(account)
                                     });
-                                    break;
+                                    continue;
                                 }
 
                                 // Attempt to decode log as a UsernameResigned event
@@ -192,7 +192,7 @@ fn collect_dirty_accounts(
                                         account.username_resigned = true;
                                         Some(account)
                                     });
-                                    break;
+                                    continue;
                                 }
                             }
                             _ => (), // ignore
@@ -209,64 +209,276 @@ fn collect_dirty_accounts(
     dirty_accounts.into_values().collect()
 }
 
-#[test]
-fn test_apply_rewards() {
-    let path = tempfile::Builder::new()
-        .prefix("evm.mdb")
-        .tempdir()
-        .unwrap();
-
-    let mut db = PersistentDB::new(crate::db::PersistentDBOptions::new(
-        path.path().to_path_buf(),
-    ))
-    .expect("database");
-    let mut pending = PendingCommit::default();
-
-    let account1 = revm::primitives::address!("bd6f65c58a46427af4b257cbe231d0ed69ed5508");
-    let account2 = revm::primitives::address!("ad6f65c58a46427af4b257cbe231d0ed69ed5508");
-
-    let mut rewards = HashMap::<Address, u128>::default();
-    rewards.insert(account1, 1234);
-    rewards.insert(account2, 0);
-
-    let result = self::apply_rewards(&mut db, &mut pending, rewards);
-    assert!(result.is_ok());
-
-    let cache_account1 = pending.cache.accounts.get(&account1).expect("account1");
-    assert!(cache_account1.account.is_some());
-    assert_eq!(
-        cache_account1.status,
-        revm::database::AccountStatus::InMemoryChange
-    );
-
-    let cache_account2 = pending.cache.accounts.get(&account2).expect("account2");
-    assert!(cache_account2.account.is_none());
-    assert_eq!(
-        cache_account2.status,
-        revm::database::AccountStatus::Destroyed
-    );
-
-    let transition_account1 = pending
-        .transitions
-        .transitions
-        .get(&account1)
-        .expect("transition_account1");
-    assert!(transition_account1.info.is_some());
-    assert_eq!(
-        transition_account1.status,
-        revm::database::AccountStatus::InMemoryChange
-    );
-    assert_eq!(transition_account1.storage_was_destroyed, false);
-
-    let transition_account2 = pending
-        .transitions
-        .transitions
-        .get(&account2)
-        .expect("transition_account2");
-    assert!(transition_account2.info.is_none());
-    assert_eq!(
-        transition_account2.status,
-        revm::database::AccountStatus::Destroyed
-    );
-    assert_eq!(transition_account2.storage_was_destroyed, true);
+#[cfg(test)]
+mod tests {
+    use std::collections::BTreeMap;
+
+    use crate::{
+        db::{GenesisInfo, PendingCommit, PersistentDB},
+        events,
+        state_changes::{AccountMergeInfo, AccountUpdate, StateChangeset},
+        state_commit::{StateCommit, apply_rewards, collect_dirty_accounts},
+    };
+    use crate::{
+        legacy::{LegacyAccountAttributes, LegacyAddress},
+        state_changes::StorageChangeset,
+    };
+    use alloy_primitives::{Address, Log, U256, address};
+    use alloy_primitives::{B256, b256};
+    use alloy_sol_types::SolEvent;
+    use bytes::Bytes;
+    use revm::{
+        context::result::{ExecutionResult, Output, ResultGas, SuccessReason},
+        primitives::HashMap,
+    };
+    use revm::{database::states::StorageSlot, state::AccountInfo};
+
+    #[test]
+    fn test_collect_dirty_accounts() {
+        let mut change_set = StateChangeset::default();
+        change_set.accounts.push((
+            address!("0000000000000000000000000000000000000001"),
+            Some(AccountInfo::from_balance(U256::from(1))),
+        ));
+        change_set.accounts.push((
+            address!("0000000000000000000000000000000000000002"),
+            Some(AccountInfo::from_balance(U256::from(1))),
+        ));
+
+        let genesis_info = GenesisInfo {
+            account: address!("0000000000000000000000000000000000000001"),
+            deployer_account: address!("0000000000000000000000000000000000000002"),
+            validator_contract: address!("0000000000000000000000000000000000000003"),
+            username_contract: address!("0000000000000000000000000000000000000004"),
+            initial_block_number: 0,
+            initial_supply: U256::from(1_000_000),
+        };
+
+        let storage = vec![
+            (
+                U256::from(1),
+                StorageSlot::new_changed(U256::ZERO, U256::from(1234)),
+            ),
+            (
+                U256::from(2),
+                StorageSlot::new_changed(U256::ZERO, U256::from(5678)),
+            ),
+        ];
+
+        change_set.storage.push(StorageChangeset {
+            address: address!("0000000000000000000000000000000000000002"),
+            storage,
+            ..Default::default()
+        });
+
+        change_set.legacy_attributes.insert(
+            address!("0000000000000000000000000000000000000001"),
+            LegacyAccountAttributes {
+                legacy_nonce: Some(5),
+                second_public_key: Some("".into()),
+                ..Default::default()
+            },
+        );
+
+        let legacy_address: LegacyAddress =
+            "DJmvhhiQFSrEQCq9FUxvcLcpcBjx7K3yLt".try_into().unwrap();
+        change_set.legacy_cold_wallets.insert(
+            legacy_address.clone(),
+            crate::legacy::LegacyColdWallet {
+                address: legacy_address.clone(),
+                balance: U256::from(255),
+                legacy_attributes: LegacyAccountAttributes {
+                    legacy_nonce: Some(3),
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+        );
+
+        change_set.merged_legacy_cold_wallets.insert(
+            address!("0000000000000000000000000000000000000001"),
+            (
+                b256!("0000000000000000000000000000000000000000000000000000000000000001"),
+                legacy_address,
+            ),
+        );
+
+        let mut results = BTreeMap::<B256, (ExecutionResult, u64)>::new();
+
+        results.insert(
+            b256!("0000000000000000000000000000000000000000000000000000000000000001"),
+            (
+                ExecutionResult::Success {
+                    reason: SuccessReason::Stop,
+                    gas: ResultGas::new(30000, 30000, 0, 0, 0),
+                    logs: vec![
+                        Log {
+                            address: genesis_info.validator_contract,
+                            data: events::Voted {
+                                validator: address!("0000000000000000000000000000000000000002"),
+                                voter: address!("0000000000000000000000000000000000000001"),
+                            }
+                            .encode_log_data(),
+                        },
+                        Log {
+                            address: genesis_info.validator_contract,
+                            data: events::Unvoted {
+                                validator: address!("0000000000000000000000000000000000000004"),
+                                voter: address!("0000000000000000000000000000000000000002"),
+                            }
+                            .encode_log_data(),
+                        },
+                        Log {
+                            address: genesis_info.username_contract,
+                            data: events::UsernameRegistered {
+                                addr: address!("0000000000000000000000000000000000000001"),
+                                username: "test".into(),
+                                previousUsername: "".into(),
+                            }
+                            .encode_log_data(),
+                        },
+                        Log {
+                            address: genesis_info.username_contract,
+                            data: events::UsernameResigned {
+                                addr: address!("0000000000000000000000000000000000000002"),
+                                username: "resigned".into(),
+                            }
+                            .encode_log_data(),
+                        },
+                        Log {
+                            address: genesis_info.validator_contract,
+                            ..Default::default()
+                        },
+                        Log {
+                            address: genesis_info.username_contract,
+                            ..Default::default()
+                        },
+                        Log {
+                            address: address!("0000000000000000000000000000000000000000"),
+                            ..Default::default()
+                        },
+                    ],
+                    output: Output::Create(
+                        alloy_primitives::Bytes(Bytes::new()),
+                        Some(address!("0000000000000000000000000000000000000001")),
+                    ),
+                },
+                0,
+            ),
+        );
+
+        results.insert(
+            b256!("0000000000000000000000000000000000000000000000000000000000000002"),
+            (
+                ExecutionResult::Revert {
+                    gas: ResultGas::new(30000, 30000, 0, 0, 0),
+                    logs: vec![],
+                    output: alloy_primitives::Bytes(Bytes::new()),
+                },
+                0,
+            ),
+        );
+
+        let state = StateCommit {
+            change_set,
+            results,
+            ..Default::default()
+        };
+
+        let mut account_updates = collect_dirty_accounts(state, &Some(genesis_info));
+        account_updates.sort_by_key(|k| k.address);
+
+        assert_eq!(
+            account_updates,
+            vec![
+                AccountUpdate {
+                    address: address!("0000000000000000000000000000000000000001"),
+                    balance: U256::ONE,
+                    nonce: 0,
+                    vote: Some(address!("0000000000000000000000000000000000000002")),
+                    unvote: None,
+                    username: Some("test".into()),
+                    username_resigned: false,
+                    merge_info: Some(AccountMergeInfo {
+                        legacy_address: "DJmvhhiQFSrEQCq9FUxvcLcpcBjx7K3yLt".try_into().unwrap(),
+                        transaction_hash: b256!(
+                            "0000000000000000000000000000000000000000000000000000000000000001"
+                        )
+                    })
+                },
+                AccountUpdate {
+                    address: address!("0000000000000000000000000000000000000002"),
+                    balance: U256::ONE,
+                    nonce: 0,
+                    vote: None,
+                    unvote: Some(address!("0000000000000000000000000000000000000004")),
+                    username: None,
+                    username_resigned: true,
+                    merge_info: None
+                }
+            ]
+        );
+    }
+
+    #[test]
+    fn test_apply_rewards() {
+        let path = tempfile::Builder::new()
+            .prefix("evm.mdb")
+            .tempdir()
+            .unwrap();
+
+        let mut db = PersistentDB::new(crate::db::PersistentDBOptions::new(
+            path.path().to_path_buf(),
+        ))
+        .expect("database");
+        let mut pending = PendingCommit::default();
+
+        let account1 = revm::primitives::address!("bd6f65c58a46427af4b257cbe231d0ed69ed5508");
+        let account2 = revm::primitives::address!("ad6f65c58a46427af4b257cbe231d0ed69ed5508");
+
+        let mut rewards = HashMap::<Address, u128>::default();
+        rewards.insert(account1, 1234);
+        rewards.insert(account2, 0);
+
+        let result = apply_rewards(&mut db, &mut pending, rewards);
+        assert!(result.is_ok());
+
+        let cache_account1 = pending.cache.accounts.get(&account1).expect("account1");
+        assert!(cache_account1.account.is_some());
+        assert_eq!(
+            cache_account1.status,
+            revm::database::AccountStatus::InMemoryChange
+        );
+
+        let cache_account2 = pending.cache.accounts.get(&account2).expect("account2");
+        assert!(cache_account2.account.is_none());
+        assert_eq!(
+            cache_account2.status,
+            revm::database::AccountStatus::Destroyed
+        );
+
+        let transition_account1 = pending
+            .transitions
+            .transitions
+            .get(&account1)
+            .expect("transition_account1");
+        assert!(transition_account1.info.is_some());
+        assert_eq!(
+            transition_account1.status,
+            revm::database::AccountStatus::InMemoryChange
+        );
+        assert_eq!(transition_account1.storage_was_destroyed, false);
+
+        let transition_account2 = pending
+            .transitions
+            .transitions
+            .get(&account2)
+            .expect("transition_account2");
+        assert!(transition_account2.info.is_none());
+        assert_eq!(
+            transition_account2.status,
+            revm::database::AccountStatus::Destroyed
+        );
+        assert_eq!(transition_account2.storage_was_destroyed, true);
+    }
 }