Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
153 changes: 153 additions & 0 deletions crates/storage/provider/src/providers/blockchain_provider.rs
Original file line number Diff line number Diff line change
Expand Up @@ -1080,6 +1080,159 @@ mod tests {
sync::Arc,
};

#[test]
fn historical_proofs_complete_masked_trie_rows() -> eyre::Result<()> {
use crate::{StaticFileProviderFactory, StaticFileSegment, StaticFileWriter};
use reth_storage_api::{StorageSettings, StorageSettingsCache, TrieWriter};
use reth_trie::{test_utils::TrieTestHarness, MultiProofTargetsV2};
use revm::state::AccountInfo;

let address = Address::with_last_byte(1);
let other_address = Address::with_last_byte(2);
let hashed_address = keccak256(address);
let account = Account { balance: U256::from(1), ..Default::default() };
// Branches 00, 01 and 02 share the cached row at 0. The first two change
// in different blocks; the third keeps proof-v2's branch-collapse path inactive.
let slots: Vec<B256> = (0..=2u8)
.flat_map(|prefix| {
(0..u64::MAX)
.map(|slot| B256::from(U256::from(slot)))
.filter(move |slot| keccak256(slot)[0] == prefix)
.take(2)
})
.collect();
let mut storage: BTreeMap<_, _> = slots.iter().map(|&slot| (slot, U256::from(1))).collect();
let mut trie = TrieTestHarness::new(
storage.iter().map(|(slot, value)| (keccak256(slot), *value)).collect(),
);
let mut blocks = Vec::<ExecutedBlock>::new();
let mut storage_roots = Vec::new();
for number in 0..=2 {
let mut output = (*ExecutedBlock::<reth_ethereum_primitives::EthPrimitives>::default()
.execution_output)
.clone();
let (state, storage_updates) = if number == 0 {
(
HashedPostState::default()
.with_accounts([
(hashed_address, Some(account)),
(keccak256(other_address), Some(account)),
])
.with_storages([(
hashed_address,
HashedStorage::from_iter(trie.storage().iter().map(|(k, v)| (*k, *v))),
)]),
trie.storage_trie_updates().clone(),
)
} else {
let slot = slots[(number as usize - 1) * 2];
let value = U256::from(number + 1);
let changes = BTreeMap::from([(keccak256(slot), value)]);
let (_, updates) = trie.get_root_with_updates(&changes);
trie.apply_changeset(changes);
storage.insert(slot, value);
let info = AccountInfo::from_balance(account.balance);
output.state = BundleState::builder(number..=number)
.state_original_account_info(address, info.clone())
.state_present_account_info(address, info)
.state_storage(
address,
std::iter::once((U256::from_be_bytes(slot.0), (U256::from(1), value)))
.collect(),
)
.revert_storage(
number,
address,
vec![(U256::from_be_bytes(slot.0), U256::from(1))],
)
.build();
(
HashedPostState::from_hashed_storage(
hashed_address,
HashedStorage::from_iter([(keccak256(slot), value)]),
),
updates,
)
};
let mut updates = TrieUpdates::default();
updates.storage_tries.insert(hashed_address, storage_updates);
let state_root = reth_trie::test_utils::state_root([
(address, (account, storage.clone())),
(other_address, (account, BTreeMap::new())),
]);
storage_roots.push(reth_trie::test_utils::storage_root(storage.clone()));
let block = Block {
header: alloy_consensus::Header {
number,
parent_hash: blocks
.last()
.map(|b| b.recovered_block().hash())
.unwrap_or_default(),
state_root,
..Default::default()
},
..Default::default()
};
blocks.push(ExecutedBlock::new(
Arc::new(RecoveredBlock::new_unhashed(block, vec![])),
Arc::new(output),
ComputedTrieData::new(
Arc::new(state.into_sorted()),
Arc::new(updates.into_sorted()),
),
));
}

let factory = create_test_provider_factory();
factory.set_storage_settings_cache(StorageSettings::v2());
let writer = factory.provider_rw()?;
writer.insert_block(blocks[0].recovered_block())?;
writer.write_hashed_state(blocks[0].hashed_state_ref())?;
writer.write_trie_updates_sorted(blocks[0].trie_updates_ref())?;
writer.commit()?;
let static_files = factory.static_file_provider();
static_files.get_writer(0, StaticFileSegment::Receipts)?.increment_block(0)?;
static_files
.get_writer(0, StaticFileSegment::AccountChangeSets)?
.append_account_changeset(vec![], 0)?;
static_files
.get_writer(0, StaticFileSegment::StorageChangeSets)?
.append_storage_changeset(vec![], 0)?;
static_files.commit()?;
let writer = factory.provider_rw()?;
writer.save_blocks(&SaveBlocksInput::new(blocks[1..].to_vec(), 0, 0, 2, 1))?;
writer.commit()?;
factory.overlay_manager().insert_block(blocks[2].clone());
let provider = BlockchainProvider::new(factory)?;

for number in [1, 2] {
let state = provider.history_by_block_hash(blocks[number].recovered_block().hash())?;
let root = blocks[number].recovered_block().state_root;
state
.multiproof_v2(
Default::default(),
MultiProofTargetsV2 {
account_targets: vec![keccak256(other_address).into()],
..Default::default()
},
)?
.account_proof(other_address, &[])?
.verify(root)?;
assert_eq!(state.state_root(HashedPostState::default())?, root);
assert_eq!(
state.storage_root(address, HashedStorage::default())?,
storage_roots[number]
);
state
.storage_proof(address, slots[2], HashedStorage::default())?
.verify(storage_roots[number])?;
let proof = state.storage_multiproof(address, &[slots[2]], HashedStorage::default())?;
assert_eq!(proof.root, storage_roots[number]);
proof.storage_proof(slots[2])?.verify(storage_roots[number])?;
}
Ok(())
}

const TEST_BLOCKS_COUNT: usize = 5;

const TEST_TRANSACTIONS_COUNT: u8 = 4;
Expand Down
25 changes: 17 additions & 8 deletions crates/storage/provider/src/providers/state/latest.rs
Original file line number Diff line number Diff line change
Expand Up @@ -153,7 +153,14 @@ impl<Provider: DBProvider + StorageSettingsCache> StorageRootProvider
hashed_storage: HashedStorage,
) -> ProviderResult<B256> {
reth_trie_db::with_adapter!(self.0, |A| {
<DbStorageRoot<'_, _, A>>::overlay_root(self.tx(), address, hashed_storage)
let input = TrieInputSorted::from_state(
HashedPostState::from_hashed_storage(
alloy_primitives::keccak256(address),
hashed_storage,
)
.into_sorted(),
);
<DbStorageRoot<'_, _, A>>::overlay_root(self.tx(), address, input)
.map_err(|err| ProviderError::Database(err.into()))
})
}
Expand Down Expand Up @@ -182,13 +189,15 @@ impl<Provider: DBProvider + StorageSettingsCache> StorageRootProvider
hashed_storage: HashedStorage,
) -> ProviderResult<StorageMultiProof> {
reth_trie_db::with_adapter!(self.0, |A| {
<DbStorageProof<'_, _, A>>::overlay_storage_multiproof(
self.tx(),
address,
slots,
hashed_storage,
)
.map_err(ProviderError::from)
let input = TrieInputSorted::from_state(
HashedPostState::from_hashed_storage(
alloy_primitives::keccak256(address),
hashed_storage,
)
.into_sorted(),
);
<DbStorageProof<'_, _, A>>::overlay_storage_multiproof(self.tx(), address, slots, input)
.map_err(ProviderError::from)
})
}
}
Expand Down
12 changes: 10 additions & 2 deletions crates/storage/provider/src/writer/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -20,6 +20,7 @@ mod tests {
use reth_trie::{
test_utils::{state_root, storage_root_prehashed},
HashedPostState, HashedStorage, StateRoot, StorageRoot, StorageRootProgress,
TrieInputSorted,
};
use reth_trie_db::{DatabaseStateRoot, DatabaseStorageRoot, LegacyKeyAdapter, PackedKeyAdapter};
use revm::database::{
Expand Down Expand Up @@ -1186,18 +1187,25 @@ mod tests {
reth_trie_db::DatabaseHashedCursorFactory<&'a TX>,
>;
let is_v2 = provider_rw.cached_storage_settings().is_v2();
let input = TrieInputSorted::from_state(HashedPostState::from_hashed_storage(
hashed_address,
updated_storage.clone(),
).into_sorted());
let storage_root = if is_v2 {
TestStorageRoot::<_, _, PackedKeyAdapter>::overlay_root(
tx,
address,
updated_storage.clone(),
input,
)
.unwrap()
} else {
TestStorageRoot::<_, _, LegacyKeyAdapter>::overlay_root(
tx,
address,
updated_storage.clone(),
TrieInputSorted::from_state(HashedPostState::from_hashed_storage(
hashed_address,
updated_storage.clone(),
).into_sorted()),
)
.unwrap()
};
Expand Down
Loading