ArkEcosystem · sebastijankuzner · May 27, 2026 · May 27, 2026 · May 27, 2026 · May 27, 2026
diff --git a/packages/core/bin/config/devnet/core/crypto.json b/packages/core/bin/config/devnet/core/crypto.json
diff --git a/packages/core/bin/config/devnet/core/genesis-wallet.json b/packages/core/bin/config/devnet/core/genesis-wallet.json
@@ -1,14 +1,14 @@
 {
-	"address": "0x20dF234537807Ff88584bEa00940694252777d7F",
+	"address": "0xEcC98f90285F69B65f9c306534e8C051DFc10E1c",
 	"consensusKeys": {
 		"compressed": true,
-		"privateKey": "6259d49de409808f4c47531686f6cb7f54dbd0a46834712c530e54a5d0ce139c",
-		"publicKey": "82951eb70bbaebc679f1210ace54d6e5b2f5d49fbd200e9ded60aa60cb827bd331a1fa251b1799265bdf2661537b0956"
+		"privateKey": "0b400cc0ad44d043081e5337d5fbb05f02cfaffa5f5c9cbdb381ea054fe9adcf",
+		"publicKey": "a314cb958eefdf5c7bb7433504bee1128da171ca3fb8a8c2203995c0c985158e4cbb744936845fc263fbc5acca92a5c0"
 	},
 	"keys": {
 		"compressed": true,
-		"privateKey": "33dbbc97be2e9a82e2e79661d3be75ed347debf95a849fa91a48319e564cabd2",
-		"publicKey": "0354872289049c8f341c0c8edb68adc3c7d9450728c1cce66831fe4a449f40f57d"
+		"privateKey": "8515189f5fc1c698a255404025c043fc840bf29d5400791b5a4b2af6e1e868dd",
+		"publicKey": "03df162bedbc767fb7403e0f2b32fa931e1f697d82f5546839424bb0357e73101a"
 	},
-	"passphrase": "rival engine erase kitten half company film glow unusual swarm hole surface kiss goat decrease large misery quiz humor romance excite lady fringe crane"
+	"passphrase": "elephant spray erode lawsuit just hole baby slam tag general trap achieve road fish grab casino quantum snow awesome vibrant rookie grow labor young"
 }
diff --git a/packages/core/bin/config/devnet/core/validators.json b/packages/core/bin/config/devnet/core/validators.json
diff --git a/packages/evm-service/source/instances/evm.test.ts b/packages/evm-service/source/instances/evm.test.ts
@@ -774,14 +774,26 @@ describe<{
 	});
 
 	it("should return state hash", async ({ instance }) => {
+		const [sender] = wallets;
+		const initialSupply = parseEther("100");
+
+		await instance.initializeGenesis({
+			account: sender.address,
+			initialSupply,
+			initialBlockNumber: 0n,
+			deployerAccount: zeroAddress,
+			usernameContract: zeroAddress,
+			validatorContract: zeroAddress,
+		});
+
 		const commitKey = { blockNumber: BigInt(0), round: BigInt(0) };
 		await instance.prepareNextCommit({ commitKey });
 
 		const hash = await instance.stateRoot(
 			commitKey,
 			"0000000000000000000000000000000000000000000000000000000000000000",
 		);
-		assert.equal(hash, "0722d8002560934d7004b8b849101024bf7ec2aaa2c3396f7292d4ac8cdae5ab");
+		assert.equal(hash, "a09fc67efe3184d31dc3f1351381ca57861c5a568c122ab3e9c9c06395c52516");
 	});
 
 	it("should return logs bloom", async ({ instance }) => {

diff --git a/packages/evm/bindings/src/lib.rs b/packages/evm/bindings/src/lib.rs
@@ -793,7 +793,13 @@ impl EvmInner {
             .get_mut(&commit_key)
             .expect("pending commit exists");
 
-        let result = state_root::calculate(&mut self.persistent_db, pending_commit, current_hash);
+        let genesis_info = self
+            .persistent_db
+            .genesis_info
+            .as_ref()
+            .expect("genesis info exists");
+
+        let result = state_root::calculate(&genesis_info, pending_commit, current_hash);
 
         match result {
             Ok(result) => Ok(result.encode_hex()),

diff --git a/packages/evm/core/src/db.rs b/packages/evm/core/src/db.rs
@@ -10,7 +10,6 @@ use std::{
 
 use alloy_primitives::Bloom;
 use heed::{Comparator, EnvFlags, EnvOpenOptions};
-use rayon::slice::ParallelSliceMut;
 use revm::{
     Database, DatabaseRef,
     context::{DBErrorMarker, result::ExecutionResult},
@@ -148,9 +147,6 @@ impl Comparator for StorageEntryDupSortCmp {
 // txHash -> receipt
 #[derive(Default, Debug, Serialize, Deserialize)]
 pub(crate) struct CommitReceipts {
-    accounts_hash: B256,
-    storage_hash: B256,
-    contracts_hash: B256,
     tx_receipts: HashMap<B256, TxReceipt>,
 }
 
@@ -266,14 +262,6 @@ pub struct PendingCommit {
 
     // Optimization to avoid unnecessary (deep) clones of commit data.
     pub built_commit: Option<StateCommit>,
-    pub commit_hashes: Option<CommitHashes>,
-}
-
-#[derive(Clone, Default, Debug, Serialize, Deserialize, PartialEq, Eq)]
-pub struct CommitHashes {
-    pub accounts_hash: B256,
-    pub contracts_hash: B256,
-    pub storage_hash: B256,
 }
 
 #[derive(Clone, Debug, Default, Serialize, PartialEq, Eq)]
@@ -823,15 +811,14 @@ impl PersistentDB {
         &self,
         state_commit: &mut StateCommit,
         commit_data: &Option<CommitData>,
-        commit_hashes: &CommitHashes,
     ) -> Result<(), Error> {
         let StateCommit {
             key,
             change_set,
             results,
         } = state_commit;
 
-        match self.commit_to_db(key, change_set, commit_data, commit_hashes, results) {
+        match self.commit_to_db(key, change_set, commit_data, results) {
             Ok(_) => return Ok(()),
             Err(err) => match &err {
                 Error::Heed(heed_err) => match heed_err {
@@ -851,7 +838,6 @@ impl PersistentDB {
         key: &CommitKey,
         change_set: &mut state_changes::StateChangeset,
         commit_data: &Option<CommitData>,
-        commit_hashes: &CommitHashes,
         results: &BTreeMap<B256, (ExecutionResult, u64)>,
     ) -> Result<(), Error> {
         assert!(!self.is_block_committed(key.0));
@@ -869,10 +855,6 @@ impl PersistentDB {
                 merged_legacy_cold_wallets,
             } = change_set;
 
-            accounts.par_sort_unstable_by_key(|a| a.0);
-            contracts.par_sort_unstable_by_key(|a| a.0);
-            storage.par_sort_unstable_by_key(|a| a.address);
-
             // Update accounts
             for (address, account) in accounts.iter() {
                 let address = AddressWrapper(*address);
@@ -954,8 +936,6 @@ impl PersistentDB {
                     }
                 }
 
-                storage.par_sort_unstable_by_key(|a| a.0);
-
                 for value in storage.into_iter() {
                     let new_storage_value = &StorageEntryWrapper(value.0, value.1.present_value());
 
@@ -1090,12 +1070,7 @@ impl PersistentDB {
             inner.commits.put(
                 rwtxn,
                 &key.0,
-                &CompressedBincode(&CommitReceipts {
-                    accounts_hash: commit_hashes.accounts_hash,
-                    contracts_hash: commit_hashes.contracts_hash,
-                    storage_hash: commit_hashes.storage_hash,
-                    tx_receipts,
-                }),
+                &CompressedBincode(&CommitReceipts { tx_receipts }),
             )?;
 
             Ok(())
@@ -1137,21 +1112,6 @@ impl PersistentDB {
         }
     }
 
-    pub fn get_committed_hashes(&self, block_number: u64) -> Result<Option<CommitHashes>, Error> {
-        let env = self.env.clone();
-        let rtxn = env.read_txn().expect("read");
-        let inner = self.inner.borrow();
-
-        match inner.commits.get(&rtxn, &block_number)? {
-            Some(receipts) => Ok(Some(CommitHashes {
-                accounts_hash: receipts.accounts_hash,
-                contracts_hash: receipts.contracts_hash,
-                storage_hash: receipts.storage_hash,
-            })),
-            None => Ok(None),
-        }
-    }
-
     pub fn is_empty(&self) -> Result<bool, Error> {
         let env = self.env.clone();
         let rtxn = env.read_txn().expect("read");
@@ -1254,7 +1214,6 @@ impl PendingCommit {
             legacy_cold_wallets: Default::default(),
             merged_legacy_cold_wallets: Default::default(),
             built_commit: Default::default(),
-            commit_hashes: Default::default(),
         }
     }
 
@@ -1298,18 +1257,17 @@ mod tests {
         account::StoredAccountInfo,
         compression::CompressedBincode,
         db::{
-            AddressWrapper, BlockHeaderData, CommitData, CommitHashes, CommitKey, CommitReceipts,
-            HashWrapper, LegacyAddressWrapper, MAP_SIZE_UNIT, PendingCommit, PersistentDB,
-            PersistentDBOptions, ProofData, StaticStringWrapper, StorageEntryWrapper,
-            StringWrapper, TransactionData, next_map_size,
+            AddressWrapper, BlockHeaderData, CommitData, CommitKey, CommitReceipts, HashWrapper,
+            LegacyAddressWrapper, MAP_SIZE_UNIT, PendingCommit, PersistentDB, PersistentDBOptions,
+            ProofData, StaticStringWrapper, StorageEntryWrapper, StringWrapper, TransactionData,
+            next_map_size,
         },
         historical::HistoricalAccountData,
         legacy::{LegacyAccountAttributes, LegacyAddress, LegacyColdWallet},
         logger::Logger,
         receipt::TxReceipt,
         state_changes::{StateChangeset, StorageChangeset},
         state_commit::{StateCommit, build_commit},
-        state_root,
     };
     use alloy_primitives::{Address, B256, Bytes, U256, address, b256};
     use revm::{
@@ -1394,7 +1352,6 @@ mod tests {
             PendingCommit {
                 key: CommitKey::default(),
                 transitions: TransitionState { transitions: state },
-                commit_hashes: Some(Default::default()),
                 ..Default::default()
             },
             Default::default(),
@@ -1425,7 +1382,6 @@ mod tests {
         let mut db = create_temp_database();
         let mut pending_commit = PendingCommit::default();
         pending_commit.built_commit = Some(build_commit(&mut pending_commit).unwrap());
-        pending_commit.commit_hashes = Some(CommitHashes::default());
 
         crate::state_commit::commit_to_db(&mut db, pending_commit, Default::default()).unwrap();
     }
@@ -1435,7 +1391,6 @@ mod tests {
         let mut db = create_temp_database();
         let mut pending_commit = PendingCommit::default();
         pending_commit.built_commit = Some(build_commit(&mut pending_commit).unwrap());
-        pending_commit.commit_hashes = None;
 
         crate::state_commit::commit_to_db(&mut db, pending_commit, Default::default()).unwrap();
     }
@@ -1490,7 +1445,6 @@ mod tests {
             PendingCommit {
                 key: CommitKey::default(),
                 transitions: TransitionState { transitions: state },
-                commit_hashes: Some(CommitHashes::default()),
                 ..Default::default()
             },
             Default::default(),
@@ -1546,7 +1500,6 @@ mod tests {
             PendingCommit {
                 key: CommitKey::default(),
                 transitions: TransitionState { transitions: state },
-                commit_hashes: Some(Default::default()),
                 ..Default::default()
             },
             Default::default(),
@@ -1584,7 +1537,6 @@ mod tests {
             PendingCommit {
                 key: CommitKey(1, 0, B256::ZERO),
                 transitions: TransitionState { transitions: state },
-                commit_hashes: Some(Default::default()),
                 ..Default::default()
             },
             Default::default(),
@@ -1647,7 +1599,6 @@ mod tests {
             PendingCommit {
                 key: CommitKey(block_number, 0, B256::ZERO),
                 transitions: TransitionState { transitions: state },
-                commit_hashes: Some(Default::default()),
                 ..Default::default()
             }
         };
@@ -2247,52 +2198,6 @@ mod tests {
         assert_eq!(read_receipts, total_receipts);
     }
 
-    #[test]
-    fn test_get_committed_hashes() {
-        let db = create_temp_database();
-
-        let hashes = db.get_committed_hashes(1).unwrap();
-        assert_eq!(hashes, None);
-
-        let accounts_hash =
-            b256!("0000000000000000000000000000000000000000000000000000000000000001");
-        let contracts_hash =
-            b256!("0000000000000000000000000000000000000000000000000000000000000002");
-        let storage_hash =
-            b256!("0000000000000000000000000000000000000000000000000000000000000003");
-
-        {
-            let mut wtxn = db.env.write_txn().unwrap();
-
-            db.inner
-                .borrow_mut()
-                .commits
-                .put(
-                    &mut wtxn,
-                    &1,
-                    &CompressedBincode(&CommitReceipts {
-                        accounts_hash,
-                        contracts_hash,
-                        storage_hash,
-                        ..Default::default()
-                    }),
-                )
-                .unwrap();
-
-            wtxn.commit().unwrap();
-        }
-
-        let hashes = db.get_committed_hashes(1).unwrap();
-        assert_eq!(
-            hashes,
-            Some(CommitHashes {
-                accounts_hash,
-                contracts_hash,
-                storage_hash
-            })
-        );
-    }
-
     #[test]
     fn test_get_legacy_attributes() {
         let db = create_temp_database();
@@ -2697,13 +2602,7 @@ mod tests {
             ..Default::default()
         };
 
-        let commit_hashes = CommitHashes {
-            accounts_hash: state_root::calculate_accounts_hash(&state.change_set).unwrap(),
-            contracts_hash: state_root::calculate_contracts_hash(&state.change_set).unwrap(),
-            storage_hash: state_root::calculate_storage_hash(&state.change_set).unwrap(),
-        };
-
-        db.commit(&mut state, &Some(data), &commit_hashes).unwrap();
+        db.commit(&mut state, &Some(data)).unwrap();
     }
 
     fn create_temp_database() -> PersistentDB {