Skip to content

feat: Remove block_number from initial sync store methods #248

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
dhyaniarun1993 merged 2 commits into from
Oct 17, 2025
Merged

feat: Remove block_number from initial sync store methods #248

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
2d6fa06
feat: Remove block_number from initial sync store methods
varun-doshi Oct 16, 2025
003330e
unstable merge + conflict resolved + bugfixes
dhyaniarun1993 Oct 17, 2025
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
8 changes: 2 additions & 6 deletions crates/optimism/trie/src/api.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -106,31 +106,27 @@ pub trait OpProofsStorage: Send + Sync + Debug {
/// capture, use [store_trie_updates](OpProofsStorage::store_trie_updates).
fn store_account_branches(
&self,
block_number: u64,
updates: Vec<(Nibbles, Option<BranchNodeCompact>)>,
account_nodes: Vec<(Nibbles, Option<BranchNodeCompact>)>,
) -> impl Future<Output = OpProofsStorageResult<()>> + Send;

/// Store a batch of storage trie branches. Used for saving existing state.
fn store_storage_branches(
&self,
block_number: u64,
hashed_address: B256,
items: Vec<(Nibbles, Option<BranchNodeCompact>)>,
storage_nodes: Vec<(Nibbles, Option<BranchNodeCompact>)>,
) -> impl Future<Output = OpProofsStorageResult<()>> + Send;

/// Store a batch of account trie leaf nodes. Used for saving existing state.
fn store_hashed_accounts(
&self,
accounts: Vec<(B256, Option<Account>)>,
block_number: u64,
) -> impl Future<Output = OpProofsStorageResult<()>> + Send;

/// Store a batch of storage trie leaf nodes. Used for saving existing state.
fn store_hashed_storages(
&self,
hashed_address: B256,
storages: Vec<(B256, U256)>,
block_number: u64,
) -> impl Future<Output = OpProofsStorageResult<()>> + Send;

/// Get the earliest block number and hash that has been stored
Expand Down
6 changes: 2 additions & 4 deletions crates/optimism/trie/src/backfill.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -214,7 +214,6 @@ impl<'a, Tx: DbTx, S: OpProofsStorage + Send> BackfillJob<'a, Tx, S> {
.into_iter()
.map(|(address, account)| (address, Some(account)))
.collect(),
0,
)
.await?;
Ok(())
Expand Down Expand Up @@ -247,7 +246,7 @@ impl<'a, Tx: DbTx, S: OpProofsStorage + Send> BackfillJob<'a, Tx, S> {

// Store each address's storage entries
for (address, storages) in by_address {
self.storage.store_hashed_storages(address, storages, 0).await?;
self.storage.store_hashed_storages(address, storages).await?;
}
Ok(())
};
Expand All @@ -272,7 +271,6 @@ impl<'a, Tx: DbTx, S: OpProofsStorage + Send> BackfillJob<'a, Tx, S> {
let save_fn = async |entries: Vec<(StoredNibbles, BranchNodeCompact)>| -> eyre::Result<()> {
self.storage
.store_account_branches(
0,
entries.into_iter().map(|(path, branch)| (path.0, Some(branch))).collect(),
)
.await?;
Expand Down Expand Up @@ -309,7 +307,7 @@ impl<'a, Tx: DbTx, S: OpProofsStorage + Send> BackfillJob<'a, Tx, S> {

// Store each address's storage trie branches
for (address, branches) in by_address {
self.storage.store_storage_branches(0, address, branches).await?;
self.storage.store_storage_branches(address, branches).await?;
}
Ok(())
};
Expand Down
71 changes: 33 additions & 38 deletions crates/optimism/trie/src/db/store.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -41,20 +41,19 @@ impl OpProofsStorage for MdbxProofsStorage {

async fn store_account_branches(
&self,
block_number: u64,
updates: Vec<(Nibbles, Option<BranchNodeCompact>)>,
account_nodes: Vec<(Nibbles, Option<BranchNodeCompact>)>,
) -> OpProofsStorageResult<()> {
let mut updates = updates;
if updates.is_empty() {
let mut account_nodes = account_nodes;
if account_nodes.is_empty() {
return Ok(());
}

updates.sort_by_key(|(key, _)| *key);
account_nodes.sort_by_key(|(key, _)| *key);

self.env.update(|tx| {
let mut cursor = tx.new_cursor::<AccountTrieHistory>()?;
for (nibble, branch_node) in updates {
let vv = VersionedValue { block_number, value: MaybeDeleted(branch_node) };
for (nibble, branch_node) in account_nodes {
let vv = VersionedValue { block_number: 0, value: MaybeDeleted(branch_node) };
cursor.append_dup(StoredNibbles::from(nibble), vv)?;
}
Ok(())
Expand All @@ -63,22 +62,21 @@ impl OpProofsStorage for MdbxProofsStorage {

async fn store_storage_branches(
&self,
block_number: u64,
hashed_address: B256,
items: Vec<(Nibbles, Option<BranchNodeCompact>)>,
storage_nodes: Vec<(Nibbles, Option<BranchNodeCompact>)>,
) -> OpProofsStorageResult<()> {
let mut items = items;
if items.is_empty() {
let mut storage_nodes = storage_nodes;
if storage_nodes.is_empty() {
return Ok(());
}

items.sort_by_key(|(key, _)| *key);
storage_nodes.sort_by_key(|(key, _)| *key);

self.env.update(|tx| {
let mut cursor = tx.new_cursor::<StorageTrieHistory>()?;
for (nibble, branch_node) in items {
for (nibble, branch_node) in storage_nodes {
let key = StorageTrieKey::new(hashed_address, StoredNibbles::from(nibble));
let vv = VersionedValue { block_number, value: MaybeDeleted(branch_node) };
let vv = VersionedValue { block_number: 0, value: MaybeDeleted(branch_node) };
cursor.append_dup(key, vv)?;
}
Ok(())
Expand All @@ -88,7 +86,6 @@ impl OpProofsStorage for MdbxProofsStorage {
async fn store_hashed_accounts(
&self,
accounts: Vec<(B256, Option<Account>)>,
block_number: u64,
) -> OpProofsStorageResult<()> {
let mut accounts = accounts;
if accounts.is_empty() {
Expand All @@ -101,7 +98,7 @@ impl OpProofsStorage for MdbxProofsStorage {
self.env.update(|tx| {
let mut cursor = tx.new_cursor::<HashedAccountHistory>()?;
for (key, account) in accounts {
let vv = VersionedValue { block_number, value: MaybeDeleted(account) };
let vv = VersionedValue { block_number: 0, value: MaybeDeleted(account) };
cursor.append_dup(key, vv)?;
}
Ok(())
Expand All @@ -112,7 +109,6 @@ impl OpProofsStorage for MdbxProofsStorage {
&self,
hashed_address: B256,
storages: Vec<(B256, U256)>,
block_number: u64,
) -> OpProofsStorageResult<()> {
let mut storages = storages;
if storages.is_empty() {
Expand All @@ -125,8 +121,10 @@ impl OpProofsStorage for MdbxProofsStorage {
self.env.update(|tx| {
let mut cursor = tx.new_cursor::<HashedStorageHistory>()?;
for (key, value) in storages {
let vv =
VersionedValue { block_number, value: MaybeDeleted(Some(StorageValue(value))) };
let vv = VersionedValue {
block_number: 0,
value: MaybeDeleted(Some(StorageValue(value))),
};
let storage_key = HashedStorageKey::new(hashed_address, key);
cursor.append_dup(storage_key, vv)?;
}
Expand Down Expand Up @@ -233,7 +231,7 @@ mod tests {

let addr = B256::from([0xAA; 32]);
let account = Account::default();
store.store_hashed_accounts(vec![(addr, Some(account))], B0).await.expect("write accounts");
store.store_hashed_accounts(vec![(addr, Some(account))]).await.expect("write accounts");

let tx = store.env.tx().expect("ro tx");
let mut cur = tx.new_cursor::<HashedAccountHistory>().expect("cursor");
Expand All @@ -257,7 +255,7 @@ mod tests {
let acc3 = Account { nonce: 1, balance: U256::from(10000u64), ..Default::default() };

store
.store_hashed_accounts(vec![(a2, None), (a1, Some(acc1)), (a3, Some(acc3))], B0)
.store_hashed_accounts(vec![(a2, None), (a1, Some(acc1)), (a3, Some(acc3))])
.await
.expect("write");

Expand Down Expand Up @@ -295,7 +293,7 @@ mod tests {

{
store
.store_hashed_accounts(vec![(a2, None), (a1, Some(acc1)), (a4, Some(acc4))], B0)
.store_hashed_accounts(vec![(a2, None), (a1, Some(acc1)), (a4, Some(acc4))])
.await
.expect("write");

Expand All @@ -318,7 +316,7 @@ mod tests {
{
// Second call
store
.store_hashed_accounts(vec![(a5, Some(acc5)), (a3, Some(acc3))], B0)
.store_hashed_accounts(vec![(a5, Some(acc5)), (a3, Some(acc3))])
.await
.expect("write");

Expand All @@ -344,7 +342,7 @@ mod tests {
let slot = B256::from([0x22; 32]);
let val = U256::from(0x1234u64);

store.store_hashed_storages(addr, vec![(slot, val)], B0).await.expect("write storage");
store.store_hashed_storages(addr, vec![(slot, val)]).await.expect("write storage");

let tx = store.env.tx().expect("ro tx");
let mut cur = tx.new_cursor::<HashedStorageHistory>().expect("cursor");
Expand All @@ -370,10 +368,7 @@ mod tests {
let s3 = B256::from([0x03; 32]);
let v3 = U256::from(3u64);

store
.store_hashed_storages(addr, vec![(s2, v2), (s1, v1), (s3, v3)], B0)
.await
.expect("write");
store.store_hashed_storages(addr, vec![(s2, v2), (s1, v1), (s3, v3)]).await.expect("write");

let tx = store.env.tx().expect("ro tx");
let mut cur = tx.new_cursor::<HashedStorageHistory>().expect("cursor");
Expand Down Expand Up @@ -406,7 +401,7 @@ mod tests {

{
store
.store_hashed_storages(addr, vec![(s2, v2), (s1, v1), (s5, v5)], B0)
.store_hashed_storages(addr, vec![(s2, v2), (s1, v1), (s5, v5)])
.await
.expect("write");

Expand All @@ -424,7 +419,7 @@ mod tests {

{
// Second call
store.store_hashed_storages(addr, vec![(s4, v4), (s3, v3)], B0).await.expect("write");
store.store_hashed_storages(addr, vec![(s4, v4), (s3, v3)]).await.expect("write");

let tx = store.env.tx().expect("ro tx");
let mut cur = tx.new_cursor::<HashedStorageHistory>().expect("cursor");
Expand All @@ -448,7 +443,7 @@ mod tests {
let branch_node = BranchNodeCompact::new(0b1, 0, 0, vec![], Some(B256::random()));
let updates = vec![(nibble, Some(branch_node.clone()))];

store.store_account_branches(B0, updates).await.expect("write");
store.store_account_branches(updates).await.expect("write");

let tx = store.env.tx().expect("ro tx");
let mut cur = tx.cursor_dup_read::<AccountTrieHistory>().expect("cursor");
Expand All @@ -474,7 +469,7 @@ mod tests {
let b3 = BranchNodeCompact::new(0b1, 0, 0, vec![], Some(B256::random()));

let updates = vec![(n2, None), (n1, Some(b1.clone())), (n3, Some(b3.clone()))];
store.store_account_branches(B0, updates.clone()).await.expect("write");
store.store_account_branches(updates.clone()).await.expect("write");

let tx = store.env.tx().expect("ro tx");
let mut cur = tx.cursor_dup_read::<AccountTrieHistory>().expect("cursor");
Expand Down Expand Up @@ -506,7 +501,7 @@ mod tests {

{
let updates1 = vec![(n2, None), (n1, Some(b1.clone())), (n4, Some(b4.clone()))];
store.store_account_branches(B0, updates1.clone()).await.expect("write");
store.store_account_branches(updates1.clone()).await.expect("write");

let tx = store.env.tx().expect("ro tx");
let mut cur = tx.cursor_dup_read::<AccountTrieHistory>().expect("cursor");
Expand All @@ -524,7 +519,7 @@ mod tests {
{
// Second call
let updates2 = vec![(n5, Some(b5.clone())), (n3, Some(b3.clone()))];
store.store_account_branches(B0, updates2.clone()).await.expect("write");
store.store_account_branches(updates2.clone()).await.expect("write");

let tx = store.env.tx().expect("ro tx");
let mut cur = tx.cursor_dup_read::<AccountTrieHistory>().expect("cursor");
Expand All @@ -550,7 +545,7 @@ mod tests {
let branch_node = BranchNodeCompact::new(0b1, 0, 0, vec![], Some(B256::random()));
let items = vec![(nibble, Some(branch_node.clone()))];

store.store_storage_branches(B0, hashed_address, items).await.expect("write");
store.store_storage_branches(hashed_address, items).await.expect("write");

let tx = store.env.tx().expect("ro tx");
let mut cur = tx.cursor_dup_read::<StorageTrieHistory>().expect("cursor");
Expand All @@ -575,7 +570,7 @@ mod tests {
let b3 = BranchNodeCompact::new(0b1, 0, 0, vec![], Some(B256::random()));

let items = vec![(n2, None), (n1, Some(b1.clone())), (n3, Some(b3.clone()))];
store.store_storage_branches(B0, hashed_address, items.clone()).await.expect("write");
store.store_storage_branches(hashed_address, items.clone()).await.expect("write");

let tx = store.env.tx().expect("ro tx");
let mut cur = tx.cursor_dup_read::<StorageTrieHistory>().expect("cursor");
Expand Down Expand Up @@ -606,7 +601,7 @@ mod tests {

{
let items1 = vec![(n2, None), (n1, Some(b1.clone())), (n5, Some(b5.clone()))];
store.store_storage_branches(B0, hashed_address, items1.clone()).await.expect("write");
store.store_storage_branches(hashed_address, items1.clone()).await.expect("write");

let tx = store.env.tx().expect("ro tx");
let mut cur = tx.cursor_dup_read::<StorageTrieHistory>().expect("cursor");
Expand All @@ -622,7 +617,7 @@ mod tests {
{
// Second call
let items2 = vec![(n4, Some(b4.clone())), (n3, Some(b3.clone()))];
store.store_storage_branches(B0, hashed_address, items2.clone()).await.expect("write");
store.store_storage_branches(hashed_address, items2.clone()).await.expect("write");

let tx = store.env.tx().expect("ro tx");
let mut cur = tx.cursor_dup_read::<StorageTrieHistory>().expect("cursor");
Expand Down
14 changes: 5 additions & 9 deletions crates/optimism/trie/src/in_memory.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -387,28 +387,26 @@ impl OpProofsStorage for InMemoryProofsStorage {

async fn store_account_branches(
&self,
block_number: u64,
updates: Vec<(Nibbles, Option<BranchNodeCompact>)>,
) -> OpProofsStorageResult<()> {
let mut inner = self.inner.write().await;

for (path, branch) in updates {
inner.account_branches.insert((block_number, path), branch);
inner.account_branches.insert((0, path), branch);
}

Ok(())
}

async fn store_storage_branches(
&self,
block_number: u64,
hashed_address: B256,
items: Vec<(Nibbles, Option<BranchNodeCompact>)>,
) -> OpProofsStorageResult<()> {
let mut inner = self.inner.write().await;

for (path, branch) in items {
inner.storage_branches.insert((block_number, hashed_address, path), branch);
inner.storage_branches.insert((0, hashed_address, path), branch);
}

Ok(())
Expand All @@ -417,12 +415,11 @@ impl OpProofsStorage for InMemoryProofsStorage {
async fn store_hashed_accounts(
&self,
accounts: Vec<(B256, Option<Account>)>,
block_number: u64,
) -> OpProofsStorageResult<()> {
let mut inner = self.inner.write().await;

for (address, account) in accounts {
inner.hashed_accounts.insert((block_number, address), account);
inner.hashed_accounts.insert((0, address), account);
}

Ok(())
Expand All @@ -432,12 +429,11 @@ impl OpProofsStorage for InMemoryProofsStorage {
&self,
hashed_address: B256,
storages: Vec<(B256, U256)>,
block_number: u64,
) -> OpProofsStorageResult<()> {
let mut inner = self.inner.write().await;

for (slot, value) in storages {
inner.hashed_storages.insert((block_number, hashed_address, slot), value);
inner.hashed_storages.insert((0, hashed_address, slot), value);
}

Ok(())
Expand Down Expand Up @@ -648,7 +644,7 @@ mod tests {
let account = Account { nonce: 1, balance: U256::from(100), bytecode_hash: None };
let hashed_address = B256::random();

storage.store_hashed_accounts(vec![(hashed_address, Some(account))], 2).await?;
storage.store_hashed_accounts(vec![(hashed_address, Some(account))]).await?;

let _cursor = storage.account_hashed_cursor(10)?;
// Note: cursor testing would require more complex setup with proper seek/next operations
Expand Down
Loading
Loading