Official Go implementation of the Ethereum protocol
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
go-ethereum/core/blockchain_sethead_test.go

1950 lines
60 KiB

// Copyright 2020 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
// Tests that setting the chain head backwards doesn't leave the database in some
// strange state with gaps in the chain, nor with block data dangling in the future.
package core
import (
"fmt"
"io/ioutil"
"math/big"
"os"
"strings"
"testing"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/consensus/ethash"
"github.com/ethereum/go-ethereum/core/rawdb"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/core/vm"
"github.com/ethereum/go-ethereum/params"
)
// rewindTest is a test case for chain rollback upon user request.
type rewindTest struct {
canonicalBlocks int // Number of blocks to generate for the canonical chain (heavier)
sidechainBlocks int // Number of blocks to generate for the side chain (lighter)
freezeThreshold uint64 // Block number until which to move things into the freezer
commitBlock uint64 // Block number for which to commit the state to disk
pivotBlock *uint64 // Pivot block number in case of fast sync
setheadBlock uint64 // Block number to set head back to
expCanonicalBlocks int // Number of canonical blocks expected to remain in the database (excl. genesis)
expSidechainBlocks int // Number of sidechain blocks expected to remain in the database (excl. genesis)
expFrozen int // Number of canonical blocks expected to be in the freezer (incl. genesis)
expHeadHeader uint64 // Block number of the expected head header
expHeadFastBlock uint64 // Block number of the expected head fast sync block
expHeadBlock uint64 // Block number of the expected head full block
}
func (tt *rewindTest) dump(crash bool) string {
buffer := new(strings.Builder)
fmt.Fprint(buffer, "Chain:\n G")
for i := 0; i < tt.canonicalBlocks; i++ {
fmt.Fprintf(buffer, "->C%d", i+1)
}
fmt.Fprint(buffer, " (HEAD)\n")
if tt.sidechainBlocks > 0 {
fmt.Fprintf(buffer, " └")
for i := 0; i < tt.sidechainBlocks; i++ {
fmt.Fprintf(buffer, "->S%d", i+1)
}
fmt.Fprintf(buffer, "\n")
}
fmt.Fprintf(buffer, "\n")
if tt.canonicalBlocks > int(tt.freezeThreshold) {
fmt.Fprint(buffer, "Frozen:\n G")
for i := 0; i < tt.canonicalBlocks-int(tt.freezeThreshold); i++ {
fmt.Fprintf(buffer, "->C%d", i+1)
}
fmt.Fprintf(buffer, "\n\n")
} else {
fmt.Fprintf(buffer, "Frozen: none\n")
}
fmt.Fprintf(buffer, "Commit: G")
if tt.commitBlock > 0 {
fmt.Fprintf(buffer, ", C%d", tt.commitBlock)
}
fmt.Fprint(buffer, "\n")
if tt.pivotBlock == nil {
fmt.Fprintf(buffer, "Pivot : none\n")
} else {
fmt.Fprintf(buffer, "Pivot : C%d\n", *tt.pivotBlock)
}
if crash {
fmt.Fprintf(buffer, "\nCRASH\n\n")
} else {
fmt.Fprintf(buffer, "\nSetHead(%d)\n\n", tt.setheadBlock)
}
fmt.Fprintf(buffer, "------------------------------\n\n")
if tt.expFrozen > 0 {
fmt.Fprint(buffer, "Expected in freezer:\n G")
for i := 0; i < tt.expFrozen-1; i++ {
fmt.Fprintf(buffer, "->C%d", i+1)
}
fmt.Fprintf(buffer, "\n\n")
}
if tt.expFrozen > 0 {
if tt.expFrozen >= tt.expCanonicalBlocks {
fmt.Fprintf(buffer, "Expected in leveldb: none\n")
} else {
fmt.Fprintf(buffer, "Expected in leveldb:\n C%d)", tt.expFrozen-1)
for i := tt.expFrozen - 1; i < tt.expCanonicalBlocks; i++ {
fmt.Fprintf(buffer, "->C%d", i+1)
}
fmt.Fprint(buffer, "\n")
if tt.expSidechainBlocks > tt.expFrozen {
fmt.Fprintf(buffer, " └")
for i := tt.expFrozen - 1; i < tt.expSidechainBlocks; i++ {
fmt.Fprintf(buffer, "->S%d", i+1)
}
fmt.Fprintf(buffer, "\n")
}
}
} else {
fmt.Fprint(buffer, "Expected in leveldb:\n G")
for i := tt.expFrozen; i < tt.expCanonicalBlocks; i++ {
fmt.Fprintf(buffer, "->C%d", i+1)
}
fmt.Fprint(buffer, "\n")
if tt.expSidechainBlocks > tt.expFrozen {
fmt.Fprintf(buffer, " └")
for i := tt.expFrozen; i < tt.expSidechainBlocks; i++ {
fmt.Fprintf(buffer, "->S%d", i+1)
}
fmt.Fprintf(buffer, "\n")
}
}
fmt.Fprintf(buffer, "\n")
fmt.Fprintf(buffer, "Expected head header : C%d\n", tt.expHeadHeader)
fmt.Fprintf(buffer, "Expected head fast block: C%d\n", tt.expHeadFastBlock)
if tt.expHeadBlock == 0 {
fmt.Fprintf(buffer, "Expected head block : G\n")
} else {
fmt.Fprintf(buffer, "Expected head block : C%d\n", tt.expHeadBlock)
}
return buffer.String()
}
// Tests a sethead for a short canonical chain where a recent block was already
// committed to disk and then the sethead called. In this case we expect the full
// chain to be rolled back to the committed block. Everything above the sethead
// point should be deleted. In between the committed block and the requested head
// the data can remain as "fast sync" data to avoid redownloading it.
func TestShortSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8 (HEAD)
//
// Frozen: none
// Commit: G, C4
// Pivot : none
//
// SetHead(7)
//
// ------------------------------
//
// Expected in leveldb:
// G->C1->C2->C3->C4->C5->C6->C7
//
// Expected head header : C7
// Expected head fast block: C7
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 8,
sidechainBlocks: 0,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: nil,
setheadBlock: 7,
expCanonicalBlocks: 7,
expSidechainBlocks: 0,
expFrozen: 0,
expHeadHeader: 7,
expHeadFastBlock: 7,
expHeadBlock: 4,
})
}
// Tests a sethead for a short canonical chain where the fast sync pivot point was
// already committed, after which sethead was called. In this case we expect the
// chain to behave like in full sync mode, rolling back to the committed block
// Everything above the sethead point should be deleted. In between the committed
// block and the requested head the data can remain as "fast sync" data to avoid
// redownloading it.
func TestShortFastSyncedSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8 (HEAD)
//
// Frozen: none
// Commit: G, C4
// Pivot : C4
//
// SetHead(7)
//
// ------------------------------
//
// Expected in leveldb:
// G->C1->C2->C3->C4->C5->C6->C7
//
// Expected head header : C7
// Expected head fast block: C7
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 8,
sidechainBlocks: 0,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: uint64ptr(4),
setheadBlock: 7,
expCanonicalBlocks: 7,
expSidechainBlocks: 0,
expFrozen: 0,
expHeadHeader: 7,
expHeadFastBlock: 7,
expHeadBlock: 4,
})
}
// Tests a sethead for a short canonical chain where the fast sync pivot point was
// not yet committed, but sethead was called. In this case we expect the chain to
// detect that it was fast syncing and delete everything from the new head, since
// we can just pick up fast syncing from there. The head full block should be set
// to the genesis.
func TestShortFastSyncingSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8 (HEAD)
//
// Frozen: none
// Commit: G
// Pivot : C4
//
// SetHead(7)
//
// ------------------------------
//
// Expected in leveldb:
// G->C1->C2->C3->C4->C5->C6->C7
//
// Expected head header : C7
// Expected head fast block: C7
// Expected head block : G
testSetHead(t, &rewindTest{
canonicalBlocks: 8,
sidechainBlocks: 0,
freezeThreshold: 16,
commitBlock: 0,
pivotBlock: uint64ptr(4),
setheadBlock: 7,
expCanonicalBlocks: 7,
expSidechainBlocks: 0,
expFrozen: 0,
expHeadHeader: 7,
expHeadFastBlock: 7,
expHeadBlock: 0,
})
}
// Tests a sethead for a short canonical chain and a shorter side chain, where a
// recent block was already committed to disk and then sethead was called. In this
// test scenario the side chain is below the committed block. In this case we expect
// the canonical full chain to be rolled back to the committed block. Everything
// above the sethead point should be deleted. In between the committed block and
// the requested head the data can remain as "fast sync" data to avoid redownloading
// it. The side chain should be left alone as it was shorter.
func TestShortOldForkedSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8 (HEAD)
// └->S1->S2->S3
//
// Frozen: none
// Commit: G, C4
// Pivot : none
//
// SetHead(7)
//
// ------------------------------
//
// Expected in leveldb:
// G->C1->C2->C3->C4->C5->C6->C7
// └->S1->S2->S3
//
// Expected head header : C7
// Expected head fast block: C7
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 8,
sidechainBlocks: 3,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: nil,
setheadBlock: 7,
expCanonicalBlocks: 7,
expSidechainBlocks: 3,
expFrozen: 0,
expHeadHeader: 7,
expHeadFastBlock: 7,
expHeadBlock: 4,
})
}
// Tests a sethead for a short canonical chain and a shorter side chain, where
// the fast sync pivot point was already committed to disk and then sethead was
// called. In this test scenario the side chain is below the committed block. In
// this case we expect the canonical full chain to be rolled back to the committed
// block. Everything above the sethead point should be deleted. In between the
// committed block and the requested head the data can remain as "fast sync" data
// to avoid redownloading it. The side chain should be left alone as it was shorter.
func TestShortOldForkedFastSyncedSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8 (HEAD)
// └->S1->S2->S3
//
// Frozen: none
// Commit: G, C4
// Pivot : C4
//
// SetHead(7)
//
// ------------------------------
//
// Expected in leveldb:
// G->C1->C2->C3->C4->C5->C6->C7
// └->S1->S2->S3
//
// Expected head header : C7
// Expected head fast block: C7
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 8,
sidechainBlocks: 3,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: uint64ptr(4),
setheadBlock: 7,
expCanonicalBlocks: 7,
expSidechainBlocks: 3,
expFrozen: 0,
expHeadHeader: 7,
expHeadFastBlock: 7,
expHeadBlock: 4,
})
}
// Tests a sethead for a short canonical chain and a shorter side chain, where
// the fast sync pivot point was not yet committed, but sethead was called. In this
// test scenario the side chain is below the committed block. In this case we expect
// the chain to detect that it was fast syncing and delete everything from the new
// head, since we can just pick up fast syncing from there. The head full block
// should be set to the genesis.
func TestShortOldForkedFastSyncingSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8 (HEAD)
// └->S1->S2->S3
//
// Frozen: none
// Commit: G
// Pivot : C4
//
// SetHead(7)
//
// ------------------------------
//
// Expected in leveldb:
// G->C1->C2->C3->C4->C5->C6->C7
// └->S1->S2->S3
//
// Expected head header : C7
// Expected head fast block: C7
// Expected head block : G
testSetHead(t, &rewindTest{
canonicalBlocks: 8,
sidechainBlocks: 3,
freezeThreshold: 16,
commitBlock: 0,
pivotBlock: uint64ptr(4),
setheadBlock: 7,
expCanonicalBlocks: 7,
expSidechainBlocks: 3,
expFrozen: 0,
expHeadHeader: 7,
expHeadFastBlock: 7,
expHeadBlock: 0,
})
}
// Tests a sethead for a short canonical chain and a shorter side chain, where a
// recent block was already committed to disk and then sethead was called. In this
// test scenario the side chain reaches above the committed block. In this case we
// expect the canonical full chain to be rolled back to the committed block. All
// data above the sethead point should be deleted. In between the committed block
// and the requested head the data can remain as "fast sync" data to avoid having
// to redownload it. The side chain should be truncated to the head set.
//
// The side chain could be left to be if the fork point was before the new head
// we are deleting to, but it would be exceedingly hard to detect that case and
// properly handle it, so we'll trade extra work in exchange for simpler code.
func TestShortNewlyForkedSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10 (HEAD)
// └->S1->S2->S3->S4->S5->S6->S7->S8
//
// Frozen: none
// Commit: G, C4
// Pivot : none
//
// SetHead(7)
//
// ------------------------------
//
// Expected in leveldb:
// G->C1->C2->C3->C4->C5->C6->C7
// └->S1->S2->S3->S4->S5->S6->S7
//
// Expected head header : C7
// Expected head fast block: C7
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 10,
sidechainBlocks: 8,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: nil,
setheadBlock: 7,
expCanonicalBlocks: 7,
expSidechainBlocks: 7,
expFrozen: 0,
expHeadHeader: 7,
expHeadFastBlock: 7,
expHeadBlock: 4,
})
}
// Tests a sethead for a short canonical chain and a shorter side chain, where
// the fast sync pivot point was already committed to disk and then sethead was
// called. In this case we expect the canonical full chain to be rolled back to
// between the committed block and the requested head the data can remain as
// "fast sync" data to avoid having to redownload it. The side chain should be
// truncated to the head set.
//
// The side chain could be left to be if the fork point was before the new head
// we are deleting to, but it would be exceedingly hard to detect that case and
// properly handle it, so we'll trade extra work in exchange for simpler code.
func TestShortNewlyForkedFastSyncedSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10 (HEAD)
// └->S1->S2->S3->S4->S5->S6->S7->S8
//
// Frozen: none
// Commit: G, C4
// Pivot : C4
//
// SetHead(7)
//
// ------------------------------
//
// Expected in leveldb:
// G->C1->C2->C3->C4->C5->C6->C7
// └->S1->S2->S3->S4->S5->S6->S7
//
// Expected head header : C7
// Expected head fast block: C7
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 10,
sidechainBlocks: 8,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: uint64ptr(4),
setheadBlock: 7,
expCanonicalBlocks: 7,
expSidechainBlocks: 7,
expFrozen: 0,
expHeadHeader: 7,
expHeadFastBlock: 7,
expHeadBlock: 4,
})
}
// Tests a sethead for a short canonical chain and a shorter side chain, where
// the fast sync pivot point was not yet committed, but sethead was called. In
// this test scenario the side chain reaches above the committed block. In this
// case we expect the chain to detect that it was fast syncing and delete
// everything from the new head, since we can just pick up fast syncing from
// there.
//
// The side chain could be left to be if the fork point was before the new head
// we are deleting to, but it would be exceedingly hard to detect that case and
// properly handle it, so we'll trade extra work in exchange for simpler code.
func TestShortNewlyForkedFastSyncingSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10 (HEAD)
// └->S1->S2->S3->S4->S5->S6->S7->S8
//
// Frozen: none
// Commit: G
// Pivot : C4
//
// SetHead(7)
//
// ------------------------------
//
// Expected in leveldb:
// G->C1->C2->C3->C4->C5->C6->C7
// └->S1->S2->S3->S4->S5->S6->S7
//
// Expected head header : C7
// Expected head fast block: C7
// Expected head block : G
testSetHead(t, &rewindTest{
canonicalBlocks: 10,
sidechainBlocks: 8,
freezeThreshold: 16,
commitBlock: 0,
pivotBlock: uint64ptr(4),
setheadBlock: 7,
expCanonicalBlocks: 7,
expSidechainBlocks: 7,
expFrozen: 0,
expHeadHeader: 7,
expHeadFastBlock: 7,
expHeadBlock: 0,
})
}
// Tests a sethead for a short canonical chain and a longer side chain, where a
// recent block was already committed to disk and then sethead was called. In this
// case we expect the canonical full chain to be rolled back to the committed block.
// All data above the sethead point should be deleted. In between the committed
// block and the requested head the data can remain as "fast sync" data to avoid
// having to redownload it. The side chain should be truncated to the head set.
//
// The side chain could be left to be if the fork point was before the new head
// we are deleting to, but it would be exceedingly hard to detect that case and
// properly handle it, so we'll trade extra work in exchange for simpler code.
func TestShortReorgedSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8 (HEAD)
// └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10
//
// Frozen: none
// Commit: G, C4
// Pivot : none
//
// SetHead(7)
//
// ------------------------------
//
// Expected in leveldb:
// G->C1->C2->C3->C4->C5->C6->C7
// └->S1->S2->S3->S4->S5->S6->S7
//
// Expected head header : C7
// Expected head fast block: C7
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 8,
sidechainBlocks: 10,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: nil,
setheadBlock: 7,
expCanonicalBlocks: 7,
expSidechainBlocks: 7,
expFrozen: 0,
expHeadHeader: 7,
expHeadFastBlock: 7,
expHeadBlock: 4,
})
}
// Tests a sethead for a short canonical chain and a longer side chain, where
// the fast sync pivot point was already committed to disk and then sethead was
// called. In this case we expect the canonical full chain to be rolled back to
// the committed block. All data above the sethead point should be deleted. In
// between the committed block and the requested head the data can remain as
// "fast sync" data to avoid having to redownload it. The side chain should be
// truncated to the head set.
//
// The side chain could be left to be if the fork point was before the new head
// we are deleting to, but it would be exceedingly hard to detect that case and
// properly handle it, so we'll trade extra work in exchange for simpler code.
func TestShortReorgedFastSyncedSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8 (HEAD)
// └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10
//
// Frozen: none
// Commit: G, C4
// Pivot : C4
//
// SetHead(7)
//
// ------------------------------
//
// Expected in leveldb:
// G->C1->C2->C3->C4->C5->C6->C7
// └->S1->S2->S3->S4->S5->S6->S7
//
// Expected head header : C7
// Expected head fast block: C7
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 8,
sidechainBlocks: 10,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: uint64ptr(4),
setheadBlock: 7,
expCanonicalBlocks: 7,
expSidechainBlocks: 7,
expFrozen: 0,
expHeadHeader: 7,
expHeadFastBlock: 7,
expHeadBlock: 4,
})
}
// Tests a sethead for a short canonical chain and a longer side chain, where
// the fast sync pivot point was not yet committed, but sethead was called. In
// this case we expect the chain to detect that it was fast syncing and delete
// everything from the new head, since we can just pick up fast syncing from
// there.
//
// The side chain could be left to be if the fork point was before the new head
// we are deleting to, but it would be exceedingly hard to detect that case and
// properly handle it, so we'll trade extra work in exchange for simpler code.
func TestShortReorgedFastSyncingSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8 (HEAD)
// └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10
//
// Frozen: none
// Commit: G
// Pivot : C4
//
// SetHead(7)
//
// ------------------------------
//
// Expected in leveldb:
// G->C1->C2->C3->C4->C5->C6->C7
// └->S1->S2->S3->S4->S5->S6->S7
//
// Expected head header : C7
// Expected head fast block: C7
// Expected head block : G
testSetHead(t, &rewindTest{
canonicalBlocks: 8,
sidechainBlocks: 10,
freezeThreshold: 16,
commitBlock: 0,
pivotBlock: uint64ptr(4),
setheadBlock: 7,
expCanonicalBlocks: 7,
expSidechainBlocks: 7,
expFrozen: 0,
expHeadHeader: 7,
expHeadFastBlock: 7,
expHeadBlock: 0,
})
}
// Tests a sethead for a long canonical chain with frozen blocks where a recent
// block - newer than the ancient limit - was already committed to disk and then
// sethead was called. In this case we expect the full chain to be rolled back
// to the committed block. Everything above the sethead point should be deleted.
// In between the committed block and the requested head the data can remain as
// "fast sync" data to avoid redownloading it.
func TestLongShallowSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
//
// Frozen:
// G->C1->C2
//
// Commit: G, C4
// Pivot : none
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2
//
// Expected in leveldb:
// C2)->C3->C4->C5->C6
//
// Expected head header : C6
// Expected head fast block: C6
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 18,
sidechainBlocks: 0,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: nil,
setheadBlock: 6,
expCanonicalBlocks: 6,
expSidechainBlocks: 0,
expFrozen: 3,
expHeadHeader: 6,
expHeadFastBlock: 6,
expHeadBlock: 4,
})
}
// Tests a sethead for a long canonical chain with frozen blocks where a recent
// block - older than the ancient limit - was already committed to disk and then
// sethead was called. In this case we expect the full chain to be rolled back
// to the committed block. Since the ancient limit was underflown, everything
// needs to be deleted onwards to avoid creating a gap.
func TestLongDeepSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
//
// Frozen:
// G->C1->C2->C3->C4->C5->C6->C7->C8
//
// Commit: G, C4
// Pivot : none
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2->C3->C4
//
// Expected in leveldb: none
//
// Expected head header : C4
// Expected head fast block: C4
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 24,
sidechainBlocks: 0,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: nil,
setheadBlock: 6,
expCanonicalBlocks: 4,
expSidechainBlocks: 0,
expFrozen: 5,
expHeadHeader: 4,
expHeadFastBlock: 4,
expHeadBlock: 4,
})
}
// Tests a sethead for a long canonical chain with frozen blocks where the fast
// sync pivot point - newer than the ancient limit - was already committed, after
// which sethead was called. In this case we expect the full chain to be rolled
// back to the committed block. Everything above the sethead point should be
// deleted. In between the committed block and the requested head the data can
// remain as "fast sync" data to avoid redownloading it.
func TestLongFastSyncedShallowSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
//
// Frozen:
// G->C1->C2
//
// Commit: G, C4
// Pivot : C4
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2
//
// Expected in leveldb:
// C2)->C3->C4->C5->C6
//
// Expected head header : C6
// Expected head fast block: C6
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 18,
sidechainBlocks: 0,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: uint64ptr(4),
setheadBlock: 6,
expCanonicalBlocks: 6,
expSidechainBlocks: 0,
expFrozen: 3,
expHeadHeader: 6,
expHeadFastBlock: 6,
expHeadBlock: 4,
})
}
// Tests a sethead for a long canonical chain with frozen blocks where the fast
// sync pivot point - older than the ancient limit - was already committed, after
// which sethead was called. In this case we expect the full chain to be rolled
// back to the committed block. Since the ancient limit was underflown, everything
// needs to be deleted onwards to avoid creating a gap.
func TestLongFastSyncedDeepSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
//
// Frozen:
// G->C1->C2->C3->C4->C5->C6->C7->C8
//
// Commit: G, C4
// Pivot : C4
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2->C3->C4
//
// Expected in leveldb: none
//
// Expected head header : C4
// Expected head fast block: C4
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 24,
sidechainBlocks: 0,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: uint64ptr(4),
setheadBlock: 6,
expCanonicalBlocks: 4,
expSidechainBlocks: 0,
expFrozen: 5,
expHeadHeader: 4,
expHeadFastBlock: 4,
expHeadBlock: 4,
})
}
// Tests a sethead for a long canonical chain with frozen blocks where the fast
// sync pivot point - newer than the ancient limit - was not yet committed, but
// sethead was called. In this case we expect the chain to detect that it was fast
// syncing and delete everything from the new head, since we can just pick up fast
// syncing from there.
func TestLongFastSyncingShallowSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
//
// Frozen:
// G->C1->C2
//
// Commit: G
// Pivot : C4
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2
//
// Expected in leveldb:
// C2)->C3->C4->C5->C6
//
// Expected head header : C6
// Expected head fast block: C6
// Expected head block : G
testSetHead(t, &rewindTest{
canonicalBlocks: 18,
sidechainBlocks: 0,
freezeThreshold: 16,
commitBlock: 0,
pivotBlock: uint64ptr(4),
setheadBlock: 6,
expCanonicalBlocks: 6,
expSidechainBlocks: 0,
expFrozen: 3,
expHeadHeader: 6,
expHeadFastBlock: 6,
expHeadBlock: 0,
})
}
// Tests a sethead for a long canonical chain with frozen blocks where the fast
// sync pivot point - older than the ancient limit - was not yet committed, but
// sethead was called. In this case we expect the chain to detect that it was fast
// syncing and delete everything from the new head, since we can just pick up fast
// syncing from there.
func TestLongFastSyncingDeepSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
//
// Frozen:
// G->C1->C2->C3->C4->C5->C6->C7->C8
//
// Commit: G
// Pivot : C4
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2->C3->C4->C5->C6
//
// Expected in leveldb: none
//
// Expected head header : C6
// Expected head fast block: C6
// Expected head block : G
testSetHead(t, &rewindTest{
canonicalBlocks: 24,
sidechainBlocks: 0,
freezeThreshold: 16,
commitBlock: 0,
pivotBlock: uint64ptr(4),
setheadBlock: 6,
expCanonicalBlocks: 6,
expSidechainBlocks: 0,
expFrozen: 7,
expHeadHeader: 6,
expHeadFastBlock: 6,
expHeadBlock: 0,
})
}
// Tests a sethead for a long canonical chain with frozen blocks and a shorter side
// chain, where a recent block - newer than the ancient limit - was already committed
// to disk and then sethead was called. In this case we expect the canonical full
// chain to be rolled back to the committed block. Everything above the sethead point
// should be deleted. In between the committed block and the requested head the data
// can remain as "fast sync" data to avoid redownloading it. The side chain is nuked
// by the freezer.
func TestLongOldForkedShallowSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
// └->S1->S2->S3
//
// Frozen:
// G->C1->C2
//
// Commit: G, C4
// Pivot : none
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2
//
// Expected in leveldb:
// C2)->C3->C4->C5->C6
//
// Expected head header : C6
// Expected head fast block: C6
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 18,
sidechainBlocks: 3,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: nil,
setheadBlock: 6,
expCanonicalBlocks: 6,
expSidechainBlocks: 0,
expFrozen: 3,
expHeadHeader: 6,
expHeadFastBlock: 6,
expHeadBlock: 4,
})
}
// Tests a sethead for a long canonical chain with frozen blocks and a shorter side
// chain, where a recent block - older than the ancient limit - was already committed
// to disk and then sethead was called. In this case we expect the canonical full
// chain to be rolled back to the committed block. Since the ancient limit was
// underflown, everything needs to be deleted onwards to avoid creating a gap. The
// side chain is nuked by the freezer.
func TestLongOldForkedDeepSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
// └->S1->S2->S3
//
// Frozen:
// G->C1->C2->C3->C4->C5->C6->C7->C8
//
// Commit: G, C4
// Pivot : none
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2->C3->C4
//
// Expected in leveldb: none
//
// Expected head header : C4
// Expected head fast block: C4
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 24,
sidechainBlocks: 3,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: nil,
setheadBlock: 6,
expCanonicalBlocks: 4,
expSidechainBlocks: 0,
expFrozen: 5,
expHeadHeader: 4,
expHeadFastBlock: 4,
expHeadBlock: 4,
})
}
// Tests a sethead for a long canonical chain with frozen blocks and a shorter
// side chain, where the fast sync pivot point - newer than the ancient limit -
// was already committed to disk and then sethead was called. In this test scenario
// the side chain is below the committed block. In this case we expect the canonical
// full chain to be rolled back to the committed block. Everything above the
// sethead point should be deleted. In between the committed block and the
// requested head the data can remain as "fast sync" data to avoid redownloading
// it. The side chain is nuked by the freezer.
func TestLongOldForkedFastSyncedShallowSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
// └->S1->S2->S3
//
// Frozen:
// G->C1->C2
//
// Commit: G, C4
// Pivot : C4
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2
//
// Expected in leveldb:
// C2)->C3->C4->C5->C6
//
// Expected head header : C6
// Expected head fast block: C6
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 18,
sidechainBlocks: 3,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: uint64ptr(4),
setheadBlock: 6,
expCanonicalBlocks: 6,
expSidechainBlocks: 0,
expFrozen: 3,
expHeadHeader: 6,
expHeadFastBlock: 6,
expHeadBlock: 4,
})
}
// Tests a sethead for a long canonical chain with frozen blocks and a shorter
// side chain, where the fast sync pivot point - older than the ancient limit -
// was already committed to disk and then sethead was called. In this test scenario
// the side chain is below the committed block. In this case we expect the canonical
// full chain to be rolled back to the committed block. Since the ancient limit was
// underflown, everything needs to be deleted onwards to avoid creating a gap. The
// side chain is nuked by the freezer.
func TestLongOldForkedFastSyncedDeepSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
// └->S1->S2->S3
//
// Frozen:
// G->C1->C2->C3->C4->C5->C6->C7->C8
//
// Commit: G, C4
// Pivot : C4
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2->C3->C4->C5->C6
//
// Expected in leveldb: none
//
// Expected head header : C6
// Expected head fast block: C6
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 24,
sidechainBlocks: 3,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: uint64ptr(4),
setheadBlock: 6,
expCanonicalBlocks: 4,
expSidechainBlocks: 0,
expFrozen: 5,
expHeadHeader: 4,
expHeadFastBlock: 4,
expHeadBlock: 4,
})
}
// Tests a sethead for a long canonical chain with frozen blocks and a shorter
// side chain, where the fast sync pivot point - newer than the ancient limit -
// was not yet committed, but sethead was called. In this test scenario the side
// chain is below the committed block. In this case we expect the chain to detect
// that it was fast syncing and delete everything from the new head, since we can
// just pick up fast syncing from there. The side chain is completely nuked by the
// freezer.
func TestLongOldForkedFastSyncingShallowSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
// └->S1->S2->S3
//
// Frozen:
// G->C1->C2
//
// Commit: G
// Pivot : C4
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2
//
// Expected in leveldb:
// C2)->C3->C4->C5->C6
//
// Expected head header : C6
// Expected head fast block: C6
// Expected head block : G
testSetHead(t, &rewindTest{
canonicalBlocks: 18,
sidechainBlocks: 3,
freezeThreshold: 16,
commitBlock: 0,
pivotBlock: uint64ptr(4),
setheadBlock: 6,
expCanonicalBlocks: 6,
expSidechainBlocks: 0,
expFrozen: 3,
expHeadHeader: 6,
expHeadFastBlock: 6,
expHeadBlock: 0,
})
}
// Tests a sethead for a long canonical chain with frozen blocks and a shorter
// side chain, where the fast sync pivot point - older than the ancient limit -
// was not yet committed, but sethead was called. In this test scenario the side
// chain is below the committed block. In this case we expect the chain to detect
// that it was fast syncing and delete everything from the new head, since we can
// just pick up fast syncing from there. The side chain is completely nuked by the
// freezer.
func TestLongOldForkedFastSyncingDeepSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
// └->S1->S2->S3
//
// Frozen:
// G->C1->C2->C3->C4->C5->C6->C7->C8
//
// Commit: G
// Pivot : C4
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2->C3->C4->C5->C6
//
// Expected in leveldb: none
//
// Expected head header : C6
// Expected head fast block: C6
// Expected head block : G
testSetHead(t, &rewindTest{
canonicalBlocks: 24,
sidechainBlocks: 3,
freezeThreshold: 16,
commitBlock: 0,
pivotBlock: uint64ptr(4),
setheadBlock: 6,
expCanonicalBlocks: 6,
expSidechainBlocks: 0,
expFrozen: 7,
expHeadHeader: 6,
expHeadFastBlock: 6,
expHeadBlock: 0,
})
}
// Tests a sethead for a long canonical chain with frozen blocks and a shorter
// side chain, where a recent block - newer than the ancient limit - was already
// committed to disk and then sethead was called. In this test scenario the side
// chain is above the committed block. In this case the freezer will delete the
// sidechain since it's dangling, reverting to TestLongShallowSetHead.
func TestLongNewerForkedShallowSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
// └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12
//
// Frozen:
// G->C1->C2
//
// Commit: G, C4
// Pivot : none
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2
//
// Expected in leveldb:
// C2)->C3->C4->C5->C6
//
// Expected head header : C6
// Expected head fast block: C6
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 18,
sidechainBlocks: 12,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: nil,
setheadBlock: 6,
expCanonicalBlocks: 6,
expSidechainBlocks: 0,
expFrozen: 3,
expHeadHeader: 6,
expHeadFastBlock: 6,
expHeadBlock: 4,
})
}
// Tests a sethead for a long canonical chain with frozen blocks and a shorter
// side chain, where a recent block - older than the ancient limit - was already
// committed to disk and then sethead was called. In this test scenario the side
// chain is above the committed block. In this case the freezer will delete the
// sidechain since it's dangling, reverting to TestLongDeepSetHead.
func TestLongNewerForkedDeepSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
// └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12
//
// Frozen:
// G->C1->C2->C3->C4->C5->C6->C7->C8
//
// Commit: G, C4
// Pivot : none
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2->C3->C4
//
// Expected in leveldb: none
//
// Expected head header : C4
// Expected head fast block: C4
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 24,
sidechainBlocks: 12,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: nil,
setheadBlock: 6,
expCanonicalBlocks: 4,
expSidechainBlocks: 0,
expFrozen: 5,
expHeadHeader: 4,
expHeadFastBlock: 4,
expHeadBlock: 4,
})
}
// Tests a sethead for a long canonical chain with frozen blocks and a shorter
// side chain, where the fast sync pivot point - newer than the ancient limit -
// was already committed to disk and then sethead was called. In this test scenario
// the side chain is above the committed block. In this case the freezer will delete
// the sidechain since it's dangling, reverting to TestLongFastSyncedShallowSetHead.
func TestLongNewerForkedFastSyncedShallowSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
// └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12
//
// Frozen:
// G->C1->C2
//
// Commit: G, C4
// Pivot : C4
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2
//
// Expected in leveldb:
// C2)->C3->C4->C5->C6
//
// Expected head header : C6
// Expected head fast block: C6
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 18,
sidechainBlocks: 12,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: uint64ptr(4),
setheadBlock: 6,
expCanonicalBlocks: 6,
expSidechainBlocks: 0,
expFrozen: 3,
expHeadHeader: 6,
expHeadFastBlock: 6,
expHeadBlock: 4,
})
}
// Tests a sethead for a long canonical chain with frozen blocks and a shorter
// side chain, where the fast sync pivot point - older than the ancient limit -
// was already committed to disk and then sethead was called. In this test scenario
// the side chain is above the committed block. In this case the freezer will delete
// the sidechain since it's dangling, reverting to TestLongFastSyncedDeepSetHead.
func TestLongNewerForkedFastSyncedDeepSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
// └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12
//
// Frozen:
// G->C1->C2->C3->C4->C5->C6->C7->C8
//
// Commit: G, C4
// Pivot : C4
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2->C3->C4
//
// Expected in leveldb: none
//
// Expected head header : C4
// Expected head fast block: C4
// Expected head block : C
testSetHead(t, &rewindTest{
canonicalBlocks: 24,
sidechainBlocks: 12,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: uint64ptr(4),
setheadBlock: 6,
expCanonicalBlocks: 4,
expSidechainBlocks: 0,
expFrozen: 5,
expHeadHeader: 4,
expHeadFastBlock: 4,
expHeadBlock: 4,
})
}
// Tests a sethead for a long canonical chain with frozen blocks and a shorter
// side chain, where the fast sync pivot point - newer than the ancient limit -
// was not yet committed, but sethead was called. In this test scenario the side
// chain is above the committed block. In this case the freezer will delete the
// sidechain since it's dangling, reverting to TestLongFastSyncinghallowSetHead.
func TestLongNewerForkedFastSyncingShallowSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
// └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12
//
// Frozen:
// G->C1->C2
//
// Commit: G
// Pivot : C4
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2
//
// Expected in leveldb:
// C2)->C3->C4->C5->C6
//
// Expected head header : C6
// Expected head fast block: C6
// Expected head block : G
testSetHead(t, &rewindTest{
canonicalBlocks: 18,
sidechainBlocks: 12,
freezeThreshold: 16,
commitBlock: 0,
pivotBlock: uint64ptr(4),
setheadBlock: 6,
expCanonicalBlocks: 6,
expSidechainBlocks: 0,
expFrozen: 3,
expHeadHeader: 6,
expHeadFastBlock: 6,
expHeadBlock: 0,
})
}
// Tests a sethead for a long canonical chain with frozen blocks and a shorter
// side chain, where the fast sync pivot point - older than the ancient limit -
// was not yet committed, but sethead was called. In this test scenario the side
// chain is above the committed block. In this case the freezer will delete the
// sidechain since it's dangling, reverting to TestLongFastSyncingDeepSetHead.
func TestLongNewerForkedFastSyncingDeepSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
// └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12
//
// Frozen:
// G->C1->C2->C3->C4->C5->C6->C7->C8
//
// Commit: G
// Pivot : C4
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2->C3->C4->C5->C6
//
// Expected in leveldb: none
//
// Expected head header : C6
// Expected head fast block: C6
// Expected head block : G
testSetHead(t, &rewindTest{
canonicalBlocks: 24,
sidechainBlocks: 12,
freezeThreshold: 16,
commitBlock: 0,
pivotBlock: uint64ptr(4),
setheadBlock: 6,
expCanonicalBlocks: 6,
expSidechainBlocks: 0,
expFrozen: 7,
expHeadHeader: 6,
expHeadFastBlock: 6,
expHeadBlock: 0,
})
}
// Tests a sethead for a long canonical chain with frozen blocks and a longer side
// chain, where a recent block - newer than the ancient limit - was already committed
// to disk and then sethead was called. In this case the freezer will delete the
// sidechain since it's dangling, reverting to TestLongShallowSetHead.
func TestLongReorgedShallowSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
// └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12->S13->S14->S15->S16->S17->S18->S19->S20->S21->S22->S23->S24->S25->S26
//
// Frozen:
// G->C1->C2
//
// Commit: G, C4
// Pivot : none
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2
//
// Expected in leveldb:
// C2)->C3->C4->C5->C6
//
// Expected head header : C6
// Expected head fast block: C6
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 18,
sidechainBlocks: 26,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: nil,
setheadBlock: 6,
expCanonicalBlocks: 6,
expSidechainBlocks: 0,
expFrozen: 3,
expHeadHeader: 6,
expHeadFastBlock: 6,
expHeadBlock: 4,
})
}
// Tests a sethead for a long canonical chain with frozen blocks and a longer side
// chain, where a recent block - older than the ancient limit - was already committed
// to disk and then sethead was called. In this case the freezer will delete the
// sidechain since it's dangling, reverting to TestLongDeepSetHead.
func TestLongReorgedDeepSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
// └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12->S13->S14->S15->S16->S17->S18->S19->S20->S21->S22->S23->S24->S25->S26
//
// Frozen:
// G->C1->C2->C3->C4->C5->C6->C7->C8
//
// Commit: G, C4
// Pivot : none
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2->C3->C4
//
// Expected in leveldb: none
//
// Expected head header : C4
// Expected head fast block: C4
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 24,
sidechainBlocks: 26,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: nil,
setheadBlock: 6,
expCanonicalBlocks: 4,
expSidechainBlocks: 0,
expFrozen: 5,
expHeadHeader: 4,
expHeadFastBlock: 4,
expHeadBlock: 4,
})
}
// Tests a sethead for a long canonical chain with frozen blocks and a longer
// side chain, where the fast sync pivot point - newer than the ancient limit -
// was already committed to disk and then sethead was called. In this case the
// freezer will delete the sidechain since it's dangling, reverting to
// TestLongFastSyncedShallowSetHead.
func TestLongReorgedFastSyncedShallowSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
// └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12->S13->S14->S15->S16->S17->S18->S19->S20->S21->S22->S23->S24->S25->S26
//
// Frozen:
// G->C1->C2
//
// Commit: G, C4
// Pivot : C4
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2
//
// Expected in leveldb:
// C2)->C3->C4->C5->C6
//
// Expected head header : C6
// Expected head fast block: C6
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 18,
sidechainBlocks: 26,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: uint64ptr(4),
setheadBlock: 6,
expCanonicalBlocks: 6,
expSidechainBlocks: 0,
expFrozen: 3,
expHeadHeader: 6,
expHeadFastBlock: 6,
expHeadBlock: 4,
})
}
// Tests a sethead for a long canonical chain with frozen blocks and a longer
// side chain, where the fast sync pivot point - older than the ancient limit -
// was already committed to disk and then sethead was called. In this case the
// freezer will delete the sidechain since it's dangling, reverting to
// TestLongFastSyncedDeepSetHead.
func TestLongReorgedFastSyncedDeepSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
// └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12->S13->S14->S15->S16->S17->S18->S19->S20->S21->S22->S23->S24->S25->S26
//
// Frozen:
// G->C1->C2->C3->C4->C5->C6->C7->C8
//
// Commit: G, C4
// Pivot : C4
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2->C3->C4
//
// Expected in leveldb: none
//
// Expected head header : C4
// Expected head fast block: C4
// Expected head block : C4
testSetHead(t, &rewindTest{
canonicalBlocks: 24,
sidechainBlocks: 26,
freezeThreshold: 16,
commitBlock: 4,
pivotBlock: uint64ptr(4),
setheadBlock: 6,
expCanonicalBlocks: 4,
expSidechainBlocks: 0,
expFrozen: 5,
expHeadHeader: 4,
expHeadFastBlock: 4,
expHeadBlock: 4,
})
}
// Tests a sethead for a long canonical chain with frozen blocks and a longer
// side chain, where the fast sync pivot point - newer than the ancient limit -
// was not yet committed, but sethead was called. In this case we expect the
// chain to detect that it was fast syncing and delete everything from the new
// head, since we can just pick up fast syncing from there. The side chain is
// completely nuked by the freezer.
func TestLongReorgedFastSyncingShallowSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
// └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12->S13->S14->S15->S16->S17->S18->S19->S20->S21->S22->S23->S24->S25->S26
//
// Frozen:
// G->C1->C2
//
// Commit: G
// Pivot : C4
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2
//
// Expected in leveldb:
// C2)->C3->C4->C5->C6
//
// Expected head header : C6
// Expected head fast block: C6
// Expected head block : G
testSetHead(t, &rewindTest{
canonicalBlocks: 18,
sidechainBlocks: 26,
freezeThreshold: 16,
commitBlock: 0,
pivotBlock: uint64ptr(4),
setheadBlock: 6,
expCanonicalBlocks: 6,
expSidechainBlocks: 0,
expFrozen: 3,
expHeadHeader: 6,
expHeadFastBlock: 6,
expHeadBlock: 0,
})
}
// Tests a sethead for a long canonical chain with frozen blocks and a longer
// side chain, where the fast sync pivot point - older than the ancient limit -
// was not yet committed, but sethead was called. In this case we expect the
// chain to detect that it was fast syncing and delete everything from the new
// head, since we can just pick up fast syncing from there. The side chain is
// completely nuked by the freezer.
func TestLongReorgedFastSyncingDeepSetHead(t *testing.T) {
// Chain:
// G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
// └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12->S13->S14->S15->S16->S17->S18->S19->S20->S21->S22->S23->S24->S25->S26
//
// Frozen:
// G->C1->C2->C3->C4->C5->C6->C7->C8
//
// Commit: G
// Pivot : C4
//
// SetHead(6)
//
// ------------------------------
//
// Expected in freezer:
// G->C1->C2->C3->C4->C5->C6
//
// Expected in leveldb: none
//
// Expected head header : C6
// Expected head fast block: C6
// Expected head block : G
testSetHead(t, &rewindTest{
canonicalBlocks: 24,
sidechainBlocks: 26,
freezeThreshold: 16,
commitBlock: 0,
pivotBlock: uint64ptr(4),
setheadBlock: 6,
expCanonicalBlocks: 6,
expSidechainBlocks: 0,
expFrozen: 7,
expHeadHeader: 6,
expHeadFastBlock: 6,
expHeadBlock: 0,
})
}
func testSetHead(t *testing.T, tt *rewindTest) {
// It's hard to follow the test case, visualize the input
//log.Root().SetHandler(log.LvlFilterHandler(log.LvlTrace, log.StreamHandler(os.Stderr, log.TerminalFormat(true))))
//fmt.Println(tt.dump(false))
// Create a temporary persistent database
datadir, err := ioutil.TempDir("", "")
if err != nil {
t.Fatalf("Failed to create temporary datadir: %v", err)
}
os.RemoveAll(datadir)
db, err := rawdb.NewLevelDBDatabaseWithFreezer(datadir, 0, 0, datadir, "")
if err != nil {
t.Fatalf("Failed to create persistent database: %v", err)
}
defer db.Close()
// Initialize a fresh chain
var (
genesis = new(Genesis).MustCommit(db)
engine = ethash.NewFullFaker()
)
chain, err := NewBlockChain(db, nil, params.AllEthashProtocolChanges, engine, vm.Config{}, nil, nil)
if err != nil {
t.Fatalf("Failed to create chain: %v", err)
}
// If sidechain blocks are needed, make a light chain and import it
var sideblocks types.Blocks
if tt.sidechainBlocks > 0 {
sideblocks, _ = GenerateChain(params.TestChainConfig, genesis, engine, rawdb.NewMemoryDatabase(), tt.sidechainBlocks, func(i int, b *BlockGen) {
b.SetCoinbase(common.Address{0x01})
})
if _, err := chain.InsertChain(sideblocks); err != nil {
t.Fatalf("Failed to import side chain: %v", err)
}
}
canonblocks, _ := GenerateChain(params.TestChainConfig, genesis, engine, rawdb.NewMemoryDatabase(), tt.canonicalBlocks, func(i int, b *BlockGen) {
b.SetCoinbase(common.Address{0x02})
b.SetDifficulty(big.NewInt(1000000))
})
if _, err := chain.InsertChain(canonblocks[:tt.commitBlock]); err != nil {
t.Fatalf("Failed to import canonical chain start: %v", err)
}
if tt.commitBlock > 0 {
chain.stateCache.TrieDB().Commit(canonblocks[tt.commitBlock-1].Root(), true, nil)
}
if _, err := chain.InsertChain(canonblocks[tt.commitBlock:]); err != nil {
t.Fatalf("Failed to import canonical chain tail: %v", err)
}
// Manually dereference anything not committed to not have to work with 128+ tries
for _, block := range sideblocks {
chain.stateCache.TrieDB().Dereference(block.Root())
}
for _, block := range canonblocks {
chain.stateCache.TrieDB().Dereference(block.Root())
}
// Force run a freeze cycle
type freezer interface {
Freeze(threshold uint64)
Ancients() (uint64, error)
}
db.(freezer).Freeze(tt.freezeThreshold)
// Set the simulated pivot block
if tt.pivotBlock != nil {
rawdb.WriteLastPivotNumber(db, *tt.pivotBlock)
}
// Set the head of the chain back to the requested number
chain.SetHead(tt.setheadBlock)
// Iterate over all the remaining blocks and ensure there are no gaps
verifyNoGaps(t, chain, true, canonblocks)
verifyNoGaps(t, chain, false, sideblocks)
verifyCutoff(t, chain, true, canonblocks, tt.expCanonicalBlocks)
verifyCutoff(t, chain, false, sideblocks, tt.expSidechainBlocks)
if head := chain.CurrentHeader(); head.Number.Uint64() != tt.expHeadHeader {
t.Errorf("Head header mismatch: have %d, want %d", head.Number, tt.expHeadHeader)
}
if head := chain.CurrentFastBlock(); head.NumberU64() != tt.expHeadFastBlock {
t.Errorf("Head fast block mismatch: have %d, want %d", head.NumberU64(), tt.expHeadFastBlock)
}
if head := chain.CurrentBlock(); head.NumberU64() != tt.expHeadBlock {
t.Errorf("Head block mismatch: have %d, want %d", head.NumberU64(), tt.expHeadBlock)
}
if frozen, err := db.(freezer).Ancients(); err != nil {
t.Errorf("Failed to retrieve ancient count: %v\n", err)
} else if int(frozen) != tt.expFrozen {
t.Errorf("Frozen block count mismatch: have %d, want %d", frozen, tt.expFrozen)
}
}
// verifyNoGaps checks that there are no gaps after the initial set of blocks in
// the database and errors if found.
func verifyNoGaps(t *testing.T, chain *BlockChain, canonical bool, inserted types.Blocks) {
t.Helper()
var end uint64
for i := uint64(0); i <= uint64(len(inserted)); i++ {
header := chain.GetHeaderByNumber(i)
if header == nil && end == 0 {
end = i
}
if header != nil && end > 0 {
if canonical {
t.Errorf("Canonical header gap between #%d-#%d", end, i-1)
} else {
t.Errorf("Sidechain header gap between #%d-#%d", end, i-1)
}
end = 0 // Reset for further gap detection
}
}
end = 0
for i := uint64(0); i <= uint64(len(inserted)); i++ {
block := chain.GetBlockByNumber(i)
if block == nil && end == 0 {
end = i
}
if block != nil && end > 0 {
if canonical {
t.Errorf("Canonical block gap between #%d-#%d", end, i-1)
} else {
t.Errorf("Sidechain block gap between #%d-#%d", end, i-1)
}
end = 0 // Reset for further gap detection
}
}
end = 0
for i := uint64(1); i <= uint64(len(inserted)); i++ {
receipts := chain.GetReceiptsByHash(inserted[i-1].Hash())
if receipts == nil && end == 0 {
end = i
}
if receipts != nil && end > 0 {
if canonical {
t.Errorf("Canonical receipt gap between #%d-#%d", end, i-1)
} else {
t.Errorf("Sidechain receipt gap between #%d-#%d", end, i-1)
}
end = 0 // Reset for further gap detection
}
}
}
// verifyCutoff checks that there are no chain data available in the chain after
// the specified limit, but that it is available before.
func verifyCutoff(t *testing.T, chain *BlockChain, canonical bool, inserted types.Blocks, head int) {
t.Helper()
for i := 1; i <= len(inserted); i++ {
if i <= head {
if header := chain.GetHeader(inserted[i-1].Hash(), uint64(i)); header == nil {
if canonical {
t.Errorf("Canonical header #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
} else {
t.Errorf("Sidechain header #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
}
}
if block := chain.GetBlock(inserted[i-1].Hash(), uint64(i)); block == nil {
if canonical {
t.Errorf("Canonical block #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
} else {
t.Errorf("Sidechain block #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
}
}
if receipts := chain.GetReceiptsByHash(inserted[i-1].Hash()); receipts == nil {
if canonical {
t.Errorf("Canonical receipts #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
} else {
t.Errorf("Sidechain receipts #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
}
}
} else {
if header := chain.GetHeader(inserted[i-1].Hash(), uint64(i)); header != nil {
if canonical {
t.Errorf("Canonical header #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
} else {
t.Errorf("Sidechain header #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
}
}
if block := chain.GetBlock(inserted[i-1].Hash(), uint64(i)); block != nil {
if canonical {
t.Errorf("Canonical block #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
} else {
t.Errorf("Sidechain block #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
}
}
if receipts := chain.GetReceiptsByHash(inserted[i-1].Hash()); receipts != nil {
if canonical {
t.Errorf("Canonical receipts #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
} else {
t.Errorf("Sidechain receipts #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
}
}
}
}
}
// uint64ptr is a weird helper to allow 1-line constant pointer creation.
func uint64ptr(n uint64) *uint64 {
return &n
}