pipeline commit trie

unclereal · unclereal · commit 71705d0de1fa · 2021-12-16T20:16:39.000+08:00
diff --git a/core/block_validator.go b/core/block_validator.go
@@ -106,7 +106,7 @@ func (v *BlockValidator) ValidateBody(block *types.Block) error {
 // transition, such as amount of used gas, the receipt roots and the state root
 // itself. ValidateState returns a database batch if the validation was a success
 // otherwise nil and an error is returned.
-func (v *BlockValidator) ValidateState(block *types.Block, statedb *state.StateDB, receipts types.Receipts, usedGas uint64) error {
+func (v *BlockValidator) ValidateState(block *types.Block, statedb *state.StateDB, receipts types.Receipts, usedGas uint64, skipHeavyVerify bool) error {
 	header := block.Header()
 	if block.GasUsed() != usedGas {
 		return fmt.Errorf("invalid gas used (remote: %d local: %d)", block.GasUsed(), usedGas)
@@ -129,13 +129,15 @@ func (v *BlockValidator) ValidateState(block *types.Block, statedb *state.StateD
 				return nil
 			}
 		},
-		func() error {
+	}
+	if !skipHeavyVerify {
+		validateFuns = append(validateFuns, func() error {
 			if root := statedb.IntermediateRoot(v.config.IsEIP158(header.Number)); header.Root != root {
 				return fmt.Errorf("invalid merkle root (remote: %x local: %x)", header.Root, root)
 			} else {
 				return nil
 			}
-		},
+		})
 	}
 	validateRes := make(chan error, len(validateFuns))
 	for _, f := range validateFuns {
diff --git a/core/blockchain.go b/core/blockchain.go
@@ -2073,7 +2073,7 @@ func (bc *BlockChain) insertChain(chain types.Blocks, verifySeals bool) (int, er
 		// Validate the state using the default validator
 		substart = time.Now()
 		if !statedb.IsLightProcessed() {
-			if err := bc.validator.ValidateState(block, statedb, receipts, usedGas); err != nil {
+			if err := bc.validator.ValidateState(block, statedb, receipts, usedGas, true); err != nil {
 				log.Error("validate state failed", "error", err)
 				bc.reportBlock(block, receipts, err)
 				return it.index, err
diff --git a/core/blockchain_test.go b/core/blockchain_test.go
@@ -156,7 +156,7 @@ func testBlockChainImport(chain types.Blocks, blockchain *BlockChain) error {
 			blockchain.reportBlock(block, receipts, err)
 			return err
 		}
-		err = blockchain.validator.ValidateState(block, statedb, receipts, usedGas)
+		err = blockchain.validator.ValidateState(block, statedb, receipts, usedGas, false)
 		if err != nil {
 			blockchain.reportBlock(block, receipts, err)
 			return err
diff --git a/core/state/snapshot/difflayer.go b/core/state/snapshot/difflayer.go
@@ -118,7 +118,8 @@ type diffLayer struct {
 	storageList map[common.Hash][]common.Hash          // List of storage slots for iterated retrievals, one per account. Any existing lists are sorted if non-nil
 	storageData map[common.Hash]map[common.Hash][]byte // Keyed storage slots for direct retrieval. one per account (nil means deleted)
 
-	diffed *bloomfilter.Filter // Bloom filter tracking all the diffed items up to the disk layer
+	verifiedCh chan struct{}
+	diffed     *bloomfilter.Filter // Bloom filter tracking all the diffed items up to the disk layer
 
 	lock sync.RWMutex
 }
@@ -168,7 +169,7 @@ func (h storageBloomHasher) Sum64() uint64 {
 
 // newDiffLayer creates a new diff on top of an existing snapshot, whether that's a low
 // level persistent database or a hierarchical diff already.
-func newDiffLayer(parent snapshot, root common.Hash, destructs map[common.Hash]struct{}, accounts map[common.Hash][]byte, storage map[common.Hash]map[common.Hash][]byte) *diffLayer {
+func newDiffLayer(parent snapshot, root common.Hash, destructs map[common.Hash]struct{}, accounts map[common.Hash][]byte, storage map[common.Hash]map[common.Hash][]byte, verified chan struct{}) *diffLayer {
 	// Create the new layer with some pre-allocated data segments
 	dl := &diffLayer{
 		parent:      parent,
@@ -177,6 +178,7 @@ func newDiffLayer(parent snapshot, root common.Hash, destructs map[common.Hash]s
 		accountData: accounts,
 		storageData: storage,
 		storageList: make(map[common.Hash][]common.Hash),
+		verifiedCh:  verified,
 	}
 	switch parent := parent.(type) {
 	case *diskLayer:
@@ -256,6 +258,15 @@ func (dl *diffLayer) Root() common.Hash {
 	return dl.root
 }
 
+// WaitVerified will wait until the diff layer been verified
+func (dl *diffLayer) WaitVerified() {
+	if dl.verifiedCh == nil {
+		return
+	}
+	<-dl.verifiedCh
+	return
+}
+
 // Parent returns the subsequent layer of a diff layer.
 func (dl *diffLayer) Parent() snapshot {
 	return dl.parent
@@ -423,8 +434,8 @@ func (dl *diffLayer) storage(accountHash, storageHash common.Hash, depth int) ([
 
 // Update creates a new layer on top of the existing snapshot diff tree with
 // the specified data items.
-func (dl *diffLayer) Update(blockRoot common.Hash, destructs map[common.Hash]struct{}, accounts map[common.Hash][]byte, storage map[common.Hash]map[common.Hash][]byte) *diffLayer {
-	return newDiffLayer(dl, blockRoot, destructs, accounts, storage)
+func (dl *diffLayer) Update(blockRoot common.Hash, destructs map[common.Hash]struct{}, accounts map[common.Hash][]byte, storage map[common.Hash]map[common.Hash][]byte, verified chan struct{}) *diffLayer {
+	return newDiffLayer(dl, blockRoot, destructs, accounts, storage, verified)
 }
 
 // flatten pushes all data from this point downwards, flattening everything into
diff --git a/core/state/snapshot/difflayer_test.go b/core/state/snapshot/difflayer_test.go
@@ -151,13 +151,13 @@ func TestMergeDelete(t *testing.T) {
 		}
 	}
 	// Add some flipAccs-flopping layers on top
-	parent := newDiffLayer(emptyLayer(), common.Hash{}, flipDrops(), flipAccs(), storage)
-	child := parent.Update(common.Hash{}, flopDrops(), flopAccs(), storage)
-	child = child.Update(common.Hash{}, flipDrops(), flipAccs(), storage)
-	child = child.Update(common.Hash{}, flopDrops(), flopAccs(), storage)
-	child = child.Update(common.Hash{}, flipDrops(), flipAccs(), storage)
-	child = child.Update(common.Hash{}, flopDrops(), flopAccs(), storage)
-	child = child.Update(common.Hash{}, flipDrops(), flipAccs(), storage)
+	parent := newDiffLayer(emptyLayer(), common.Hash{}, flipDrops(), flipAccs(), storage, nil)
+	child := parent.Update(common.Hash{}, flopDrops(), flopAccs(), storage, nil)
+	child = child.Update(common.Hash{}, flipDrops(), flipAccs(), storage, nil)
+	child = child.Update(common.Hash{}, flopDrops(), flopAccs(), storage, nil)
+	child = child.Update(common.Hash{}, flipDrops(), flipAccs(), storage, nil)
+	child = child.Update(common.Hash{}, flopDrops(), flopAccs(), storage, nil)
+	child = child.Update(common.Hash{}, flipDrops(), flipAccs(), storage, nil)
 
 	if data, _ := child.Account(h1); data == nil {
 		t.Errorf("last diff layer: expected %x account to be non-nil", h1)
@@ -209,7 +209,7 @@ func TestInsertAndMerge(t *testing.T) {
 			accounts  = make(map[common.Hash][]byte)
 			storage   = make(map[common.Hash]map[common.Hash][]byte)
 		)
-		parent = newDiffLayer(emptyLayer(), common.Hash{}, destructs, accounts, storage)
+		parent = newDiffLayer(emptyLayer(), common.Hash{}, destructs, accounts, storage, nil)
 	}
 	{
 		var (
@@ -220,7 +220,7 @@ func TestInsertAndMerge(t *testing.T) {
 		accounts[acc] = randomAccount()
 		storage[acc] = make(map[common.Hash][]byte)
 		storage[acc][slot] = []byte{0x01}
-		child = newDiffLayer(parent, common.Hash{}, destructs, accounts, storage)
+		child = newDiffLayer(parent, common.Hash{}, destructs, accounts, storage, nil)
 	}
 	// And flatten
 	merged := (child.flatten()).(*diffLayer)
@@ -256,7 +256,7 @@ func BenchmarkSearch(b *testing.B) {
 		for i := 0; i < 10000; i++ {
 			accounts[randomHash()] = randomAccount()
 		}
-		return newDiffLayer(parent, common.Hash{}, destructs, accounts, storage)
+		return newDiffLayer(parent, common.Hash{}, destructs, accounts, storage, nil)
 	}
 	var layer snapshot
 	layer = emptyLayer()
@@ -298,7 +298,7 @@ func BenchmarkSearchSlot(b *testing.B) {
 			accStorage[randomHash()] = value
 			storage[accountKey] = accStorage
 		}
-		return newDiffLayer(parent, common.Hash{}, destructs, accounts, storage)
+		return newDiffLayer(parent, common.Hash{}, destructs, accounts, storage, nil)
 	}
 	var layer snapshot
 	layer = emptyLayer()
@@ -336,7 +336,7 @@ func BenchmarkFlatten(b *testing.B) {
 			}
 			storage[accountKey] = accStorage
 		}
-		return newDiffLayer(parent, common.Hash{}, destructs, accounts, storage)
+		return newDiffLayer(parent, common.Hash{}, destructs, accounts, storage, nil)
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
@@ -386,7 +386,7 @@ func BenchmarkJournal(b *testing.B) {
 			}
 			storage[accountKey] = accStorage
 		}
-		return newDiffLayer(parent, common.Hash{}, destructs, accounts, storage)
+		return newDiffLayer(parent, common.Hash{}, destructs, accounts, storage, nil)
 	}
 	layer := snapshot(new(diskLayer))
 	for i := 1; i < 128; i++ {
diff --git a/core/state/snapshot/disklayer.go b/core/state/snapshot/disklayer.go
@@ -49,6 +49,10 @@ func (dl *diskLayer) Root() common.Hash {
 	return dl.root
 }
 
+func (dl *diskLayer) WaitVerified() {
+	return
+}
+
 // Parent always returns nil as there's no layer below the disk.
 func (dl *diskLayer) Parent() snapshot {
 	return nil
@@ -161,6 +165,6 @@ func (dl *diskLayer) Storage(accountHash, storageHash common.Hash) ([]byte, erro
 // Update creates a new layer on top of the existing snapshot diff tree with
 // the specified data items. Note, the maps are retained by the method to avoid
 // copying everything.
-func (dl *diskLayer) Update(blockHash common.Hash, destructs map[common.Hash]struct{}, accounts map[common.Hash][]byte, storage map[common.Hash]map[common.Hash][]byte) *diffLayer {
-	return newDiffLayer(dl, blockHash, destructs, accounts, storage)
+func (dl *diskLayer) Update(blockHash common.Hash, destructs map[common.Hash]struct{}, accounts map[common.Hash][]byte, storage map[common.Hash]map[common.Hash][]byte, verified chan struct{}) *diffLayer {
+	return newDiffLayer(dl, blockHash, destructs, accounts, storage, verified)
 }
diff --git a/core/state/snapshot/iterator_test.go b/core/state/snapshot/iterator_test.go
@@ -53,7 +53,7 @@ func TestAccountIteratorBasics(t *testing.T) {
 		}
 	}
 	// Add some (identical) layers on top
-	diffLayer := newDiffLayer(emptyLayer(), common.Hash{}, copyDestructs(destructs), copyAccounts(accounts), copyStorage(storage))
+	diffLayer := newDiffLayer(emptyLayer(), common.Hash{}, copyDestructs(destructs), copyAccounts(accounts), copyStorage(storage), nil)
 	it := diffLayer.AccountIterator(common.Hash{})
 	verifyIterator(t, 100, it, verifyNothing) // Nil is allowed for single layer iterator
 
@@ -91,7 +91,7 @@ func TestStorageIteratorBasics(t *testing.T) {
 		nilStorage[h] = nilstorage
 	}
 	// Add some (identical) layers on top
-	diffLayer := newDiffLayer(emptyLayer(), common.Hash{}, nil, copyAccounts(accounts), copyStorage(storage))
+	diffLayer := newDiffLayer(emptyLayer(), common.Hash{}, nil, copyAccounts(accounts), copyStorage(storage), nil)
 	for account := range accounts {
 		it, _ := diffLayer.StorageIterator(account, common.Hash{})
 		verifyIterator(t, 100, it, verifyNothing) // Nil is allowed for single layer iterator
diff --git a/core/state/snapshot/journal.go b/core/state/snapshot/journal.go
@@ -243,7 +243,7 @@ func loadDiffLayer(parent snapshot, r *rlp.Stream) (snapshot, error) {
 		}
 		storageData[entry.Hash] = slots
 	}
-	return loadDiffLayer(newDiffLayer(parent, root, destructSet, accountData, storageData), r)
+	return loadDiffLayer(newDiffLayer(parent, root, destructSet, accountData, storageData, nil), r)
 }
 
 // Journal terminates any in-progress snapshot generation, also implicitly pushing
diff --git a/core/state/snapshot/snapshot.go b/core/state/snapshot/snapshot.go
@@ -101,6 +101,9 @@ type Snapshot interface {
 	// Root returns the root hash for which this snapshot was made.
 	Root() common.Hash
 
+	// WaitVerified will wait until the Snapshot been verified
+	WaitVerified()
+
 	// Account directly retrieves the account associated with a particular hash in
 	// the snapshot slim data format.
 	Account(hash common.Hash) (*Account, error)
@@ -130,7 +133,7 @@ type snapshot interface {
 	// the specified data items.
 	//
 	// Note, the maps are retained by the method to avoid copying everything.
-	Update(blockRoot common.Hash, destructs map[common.Hash]struct{}, accounts map[common.Hash][]byte, storage map[common.Hash]map[common.Hash][]byte) *diffLayer
+	Update(blockRoot common.Hash, destructs map[common.Hash]struct{}, accounts map[common.Hash][]byte, storage map[common.Hash]map[common.Hash][]byte, verified chan struct{}) *diffLayer
 
 	// Journal commits an entire diff hierarchy to disk into a single journal entry.
 	// This is meant to be used during shutdown to persist the snapshot without
@@ -289,6 +292,14 @@ func (t *Tree) Snapshot(blockRoot common.Hash) Snapshot {
 	return t.layers[blockRoot]
 }
 
+// Snapshot retrieves a snapshot belonging to the given block root, or nil if no
+func (t *Tree) Remove(blockRoot common.Hash) {
+	t.lock.RLock()
+	defer t.lock.RUnlock()
+
+	delete(t.layers, blockRoot)
+}
+
 // Snapshots returns all visited layers from the topmost layer with specific
 // root and traverses downward. The layer amount is limited by the given number.
 // If nodisk is set, then disk layer is excluded.
@@ -322,14 +333,14 @@ func (t *Tree) Snapshots(root common.Hash, limits int, nodisk bool) []Snapshot {
 	return ret
 }
 
-func (t *Tree) Update(blockRoot common.Hash, parentRoot common.Hash, destructs map[common.Address]struct{}, accounts map[common.Address][]byte, storage map[common.Address]map[string][]byte) error {
+func (t *Tree) Update(blockRoot common.Hash, parentRoot common.Hash, destructs map[common.Address]struct{}, accounts map[common.Address][]byte, storage map[common.Address]map[string][]byte, verified chan struct{}) error {
 	hashDestructs, hashAccounts, hashStorage := transformSnapData(destructs, accounts, storage)
-	return t.update(blockRoot, parentRoot, hashDestructs, hashAccounts, hashStorage)
+	return t.update(blockRoot, parentRoot, hashDestructs, hashAccounts, hashStorage, verified)
 }
 
 // Update adds a new snapshot into the tree, if that can be linked to an existing
 // old parent. It is disallowed to insert a disk layer (the origin of all).
-func (t *Tree) update(blockRoot common.Hash, parentRoot common.Hash, destructs map[common.Hash]struct{}, accounts map[common.Hash][]byte, storage map[common.Hash]map[common.Hash][]byte) error {
+func (t *Tree) update(blockRoot common.Hash, parentRoot common.Hash, destructs map[common.Hash]struct{}, accounts map[common.Hash][]byte, storage map[common.Hash]map[common.Hash][]byte, verified chan struct{}) error {
 	// Reject noop updates to avoid self-loops in the snapshot tree. This is a
 	// special case that can only happen for Clique networks where empty blocks
 	// don't modify the state (0 block subsidy).
@@ -344,7 +355,7 @@ func (t *Tree) update(blockRoot common.Hash, parentRoot common.Hash, destructs m
 	if parent == nil {
 		return fmt.Errorf("parent [%#x] snapshot missing", parentRoot)
 	}
-	snap := parent.(snapshot).Update(blockRoot, destructs, accounts, storage)
+	snap := parent.(snapshot).Update(blockRoot, destructs, accounts, storage, verified)
 
 	// Save the new snapshot for later
 	t.lock.Lock()
diff --git a/core/state/statedb.go b/core/state/statedb.go
diff --git a/core/state_processor.go b/core/state_processor.go
diff --git a/core/types.go b/core/types.go

Original file line number	Diff line number	Diff line change
`@@ -156,7 +156,7 @@ func testBlockChainImport(chain types.Blocks, blockchain *BlockChain) error {`
`156`	`156`	`blockchain.reportBlock(block, receipts, err)`
`157`	`157`	`return err`
`158`	`158`	`}`
`159`		`- err = blockchain.validator.ValidateState(block, statedb, receipts, usedGas)`
	`159`	`+ err = blockchain.validator.ValidateState(block, statedb, receipts, usedGas, false)`
`160`	`160`	`if err != nil {`
`161`	`161`	`blockchain.reportBlock(block, receipts, err)`
`162`	`162`	`return err`
Original file line number	Diff line number	Diff line change
`@@ -151,13 +151,13 @@ func TestMergeDelete(t *testing.T) {`
`151`	`151`	`}`
`152`	`152`	`}`
`153`	`153`	`// Add some flipAccs-flopping layers on top`
`154`		`- parent := newDiffLayer(emptyLayer(), common.Hash{}, flipDrops(), flipAccs(), storage)`
`155`		`- child := parent.Update(common.Hash{}, flopDrops(), flopAccs(), storage)`
`156`		`- child = child.Update(common.Hash{}, flipDrops(), flipAccs(), storage)`
`157`		`- child = child.Update(common.Hash{}, flopDrops(), flopAccs(), storage)`
`158`		`- child = child.Update(common.Hash{}, flipDrops(), flipAccs(), storage)`
`159`		`- child = child.Update(common.Hash{}, flopDrops(), flopAccs(), storage)`
`160`		`- child = child.Update(common.Hash{}, flipDrops(), flipAccs(), storage)`
	`154`	`+ parent := newDiffLayer(emptyLayer(), common.Hash{}, flipDrops(), flipAccs(), storage, nil)`
	`155`	`+ child := parent.Update(common.Hash{}, flopDrops(), flopAccs(), storage, nil)`
	`156`	`+ child = child.Update(common.Hash{}, flipDrops(), flipAccs(), storage, nil)`
	`157`	`+ child = child.Update(common.Hash{}, flopDrops(), flopAccs(), storage, nil)`
	`158`	`+ child = child.Update(common.Hash{}, flipDrops(), flipAccs(), storage, nil)`
	`159`	`+ child = child.Update(common.Hash{}, flopDrops(), flopAccs(), storage, nil)`
	`160`	`+ child = child.Update(common.Hash{}, flipDrops(), flipAccs(), storage, nil)`
`161`	`161`
`162`	`162`	`if data, _ := child.Account(h1); data == nil {`
`163`	`163`	`t.Errorf("last diff layer: expected %x account to be non-nil", h1)`
`@@ -209,7 +209,7 @@ func TestInsertAndMerge(t *testing.T) {`
`209`	`209`	`accounts = make(map[common.Hash][]byte)`
`210`	`210`	`storage = make(map[common.Hash]map[common.Hash][]byte)`
`211`	`211`	`)`
`212`		`- parent = newDiffLayer(emptyLayer(), common.Hash{}, destructs, accounts, storage)`
	`212`	`+ parent = newDiffLayer(emptyLayer(), common.Hash{}, destructs, accounts, storage, nil)`
`213`	`213`	`}`
`214`	`214`	`{`
`215`	`215`	`var (`
`@@ -220,7 +220,7 @@ func TestInsertAndMerge(t *testing.T) {`
`220`	`220`	`accounts[acc] = randomAccount()`
`221`	`221`	`storage[acc] = make(map[common.Hash][]byte)`
`222`	`222`	`storage[acc][slot] = []byte{0x01}`
`223`		`- child = newDiffLayer(parent, common.Hash{}, destructs, accounts, storage)`
	`223`	`+ child = newDiffLayer(parent, common.Hash{}, destructs, accounts, storage, nil)`
`224`	`224`	`}`
`225`	`225`	`// And flatten`
`226`	`226`	`merged := (child.flatten()).(*diffLayer)`
`@@ -256,7 +256,7 @@ func BenchmarkSearch(b *testing.B) {`
`256`	`256`	`for i := 0; i < 10000; i++ {`
`257`	`257`	`accounts[randomHash()] = randomAccount()`
`258`	`258`	`}`
`259`		`- return newDiffLayer(parent, common.Hash{}, destructs, accounts, storage)`
	`259`	`+ return newDiffLayer(parent, common.Hash{}, destructs, accounts, storage, nil)`
`260`	`260`	`}`
`261`	`261`	`var layer snapshot`
`262`	`262`	`layer = emptyLayer()`
`@@ -298,7 +298,7 @@ func BenchmarkSearchSlot(b *testing.B) {`
`298`	`298`	`accStorage[randomHash()] = value`
`299`	`299`	`storage[accountKey] = accStorage`
`300`	`300`	`}`
`301`		`- return newDiffLayer(parent, common.Hash{}, destructs, accounts, storage)`
	`301`	`+ return newDiffLayer(parent, common.Hash{}, destructs, accounts, storage, nil)`
`302`	`302`	`}`
`303`	`303`	`var layer snapshot`
`304`	`304`	`layer = emptyLayer()`
`@@ -336,7 +336,7 @@ func BenchmarkFlatten(b *testing.B) {`
`336`	`336`	`}`
`337`	`337`	`storage[accountKey] = accStorage`
`338`	`338`	`}`
`339`		`- return newDiffLayer(parent, common.Hash{}, destructs, accounts, storage)`
	`339`	`+ return newDiffLayer(parent, common.Hash{}, destructs, accounts, storage, nil)`
`340`	`340`	`}`
`341`	`341`	`b.ResetTimer()`
`342`	`342`	`for i := 0; i < b.N; i++ {`
`@@ -386,7 +386,7 @@ func BenchmarkJournal(b *testing.B) {`
`386`	`386`	`}`
`387`	`387`	`storage[accountKey] = accStorage`
`388`	`388`	`}`
`389`		`- return newDiffLayer(parent, common.Hash{}, destructs, accounts, storage)`
	`389`	`+ return newDiffLayer(parent, common.Hash{}, destructs, accounts, storage, nil)`
`390`	`390`	`}`
`391`	`391`	`layer := snapshot(new(diskLayer))`
`392`	`392`	`for i := 1; i < 128; i++ {`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ func TestAccountIteratorBasics(t *testing.T) {`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`	`// Add some (identical) layers on top`
`56`		`- diffLayer := newDiffLayer(emptyLayer(), common.Hash{}, copyDestructs(destructs), copyAccounts(accounts), copyStorage(storage))`
	`56`	`+ diffLayer := newDiffLayer(emptyLayer(), common.Hash{}, copyDestructs(destructs), copyAccounts(accounts), copyStorage(storage), nil)`
`57`	`57`	`it := diffLayer.AccountIterator(common.Hash{})`
`58`	`58`	`verifyIterator(t, 100, it, verifyNothing) // Nil is allowed for single layer iterator`
`59`	`59`
`@@ -91,7 +91,7 @@ func TestStorageIteratorBasics(t *testing.T) {`
`91`	`91`	`nilStorage[h] = nilstorage`
`92`	`92`	`}`
`93`	`93`	`// Add some (identical) layers on top`
`94`		`- diffLayer := newDiffLayer(emptyLayer(), common.Hash{}, nil, copyAccounts(accounts), copyStorage(storage))`
	`94`	`+ diffLayer := newDiffLayer(emptyLayer(), common.Hash{}, nil, copyAccounts(accounts), copyStorage(storage), nil)`
`95`	`95`	`for account := range accounts {`
`96`	`96`	`it, _ := diffLayer.StorageIterator(account, common.Hash{})`
`97`	`97`	`verifyIterator(t, 100, it, verifyNothing) // Nil is allowed for single layer iterator`
Original file line number	Diff line number	Diff line change
`@@ -243,7 +243,7 @@ func loadDiffLayer(parent snapshot, r *rlp.Stream) (snapshot, error) {`
`243`	`243`	`}`
`244`	`244`	`storageData[entry.Hash] = slots`
`245`	`245`	`}`
`246`		`- return loadDiffLayer(newDiffLayer(parent, root, destructSet, accountData, storageData), r)`
	`246`	`+ return loadDiffLayer(newDiffLayer(parent, root, destructSet, accountData, storageData, nil), r)`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`// Journal terminates any in-progress snapshot generation, also implicitly pushing`