Merge pull request #18988 from holiman/repro18977

core: repro #18977

core/blockchain.go

@@ -979,20 +979,26 @@ func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types.
  triedb.Cap(limit - ethdb.IdealBatchSize)
  }
  // Find the next state trie we need to commit
- header := bc.GetHeaderByNumber(current - triesInMemory)
- chosen := header.Number.Uint64()
+ chosen := current - triesInMemory
 
  // If we exceeded out time allowance, flush an entire trie to disk
  if bc.gcproc > bc.cacheConfig.TrieTimeLimit {
- // If we're exceeding limits but haven't reached a large enough memory gap,
- // warn the user that the system is becoming unstable.
- if chosen < lastWrite+triesInMemory && bc.gcproc >= 2*bc.cacheConfig.TrieTimeLimit {
- log.Info("State in memory for too long, committing", "time", bc.gcproc, "allowance", bc.cacheConfig.TrieTimeLimit, "optimum", float64(chosen-lastWrite)/triesInMemory)
+ // If the header is missing (canonical chain behind), we're reorging a low
+ // diff sidechain. Suspend committing until this operation is completed.
+ header := bc.GetHeaderByNumber(chosen)
+ if header == nil {
+ log.Warn("Reorg in progress, trie commit postponed", "number", chosen)
+ } else {
+ // If we're exceeding limits but haven't reached a large enough memory gap,
+ // warn the user that the system is becoming unstable.
+ if chosen < lastWrite+triesInMemory && bc.gcproc >= 2*bc.cacheConfig.TrieTimeLimit {
+ log.Info("State in memory for too long, committing", "time", bc.gcproc, "allowance", bc.cacheConfig.TrieTimeLimit, "optimum", float64(chosen-lastWrite)/triesInMemory)
+ }
+ // Flush an entire trie and restart the counters
+ triedb.Commit(header.Root, true)
+ lastWrite = chosen
+ bc.gcproc = 0
  }
- // Flush an entire trie and restart the counters
- triedb.Commit(header.Root, true)
- lastWrite = chosen
- bc.gcproc = 0
  }
  // Garbage collect anything below our required write retention
  for !bc.triegc.Empty() {
@@ -1324,7 +1330,7 @@ func (bc *BlockChain) insertSidechain(block *types.Block, it *insertIterator) (i
  if err := bc.WriteBlockWithoutState(block, externTd); err != nil {
  return it.index, nil, nil, err
  }
- log.Debug("Inserted sidechain block", "number", block.Number(), "hash", block.Hash(),
+ log.Debug("Injected sidechain block", "number", block.Number(), "hash", block.Hash(),
  "diff", block.Difficulty(), "elapsed", common.PrettyDuration(time.Since(start)),
  "txs", len(block.Transactions()), "gas", block.GasUsed(), "uncles", len(block.Uncles()),
  "root", block.Root())

core/blockchain_test.go

@@ -1483,3 +1483,58 @@ func BenchmarkBlockChain_1x1000Executions(b *testing.B) {
 
  benchmarkLargeNumberOfValueToNonexisting(b, numTxs, numBlocks, recipientFn, dataFn)
 }
+
+// Tests that importing a very large side fork, which is larger than the canon chain,
+// but where the difficulty per block is kept low: this means that it will not
+// overtake the 'canon' chain until after it's passed canon by about 200 blocks.
+//
+// Details at:
+// - https://github.com/ethereum/go-ethereum/issues/18977
+// - https://github.com/ethereum/go-ethereum/pull/18988
+func TestLowDiffLongChain(t *testing.T) {
+ // Generate a canonical chain to act as the main dataset
+ engine := ethash.NewFaker()
+ db := ethdb.NewMemDatabase()
+ genesis := new(Genesis).MustCommit(db)
+
+ // We must use a pretty long chain to ensure that the fork doesn't overtake us
+ // until after at least 128 blocks post tip
+ blocks, _ := GenerateChain(params.TestChainConfig, genesis, engine, db, 6*triesInMemory, func(i int, b *BlockGen) {
+ b.SetCoinbase(common.Address{1})
+ b.OffsetTime(-9)
+ })
+
+ // Import the canonical chain
+ diskdb := ethdb.NewMemDatabase()
+ new(Genesis).MustCommit(diskdb)
+
+ chain, err := NewBlockChain(diskdb, nil, params.TestChainConfig, engine, vm.Config{}, nil)
+ if err != nil {
+ t.Fatalf("failed to create tester chain: %v", err)
+ }
+ if n, err := chain.InsertChain(blocks); err != nil {
+ t.Fatalf("block %d: failed to insert into chain: %v", n, err)
+ }
+ // Generate fork chain, starting from an early block
+ parent := blocks[10]
+ fork, _ := GenerateChain(params.TestChainConfig, parent, engine, db, 8*triesInMemory, func(i int, b *BlockGen) {
+ b.SetCoinbase(common.Address{2})
+ })
+
+ // And now import the fork
+ if i, err := chain.InsertChain(fork); err != nil {
+ t.Fatalf("block %d: failed to insert into chain: %v", i, err)
+ }
+ head := chain.CurrentBlock()
+ if got := fork[len(fork)-1].Hash(); got != head.Hash() {
+ t.Fatalf("head wrong, expected %x got %x", head.Hash(), got)
+ }
+ // Sanity check that all the canonical numbers are present
+ header := chain.CurrentHeader()
+ for number := head.NumberU64(); number > 0; number-- {
+ if hash := chain.GetHeaderByNumber(number).Hash(); hash != header.Hash() {
+ t.Fatalf("header %d: canonical hash mismatch: have %x, want %x", number, hash, header.Hash())
+ }
+ header = chain.GetHeader(header.ParentHash, number-1)
+ }
+}

core/chain_makers.go

@@ -149,7 +149,7 @@ func (b *BlockGen) PrevBlock(index int) *types.Block {
 // associated difficulty. It's useful to test scenarios where forking is not
 // tied to chain length directly.
 func (b *BlockGen) OffsetTime(seconds int64) {
- b.header.Time.Add(b.header.Time, new(big.Int).SetInt64(seconds))
+ b.header.Time.Add(b.header.Time, big.NewInt(seconds))
  if b.header.Time.Cmp(b.parent.Header().Time) <= 0 {
  panic("block time out of range")
  }