mirror of
https://github.com/ethereum/go-ethereum.git
synced 2026-07-26 14:46:42 +00:00
feat(tracers): add tests for debug tracing methods
Adds tests for StandardTraceBlockToFile, StandardTraceBadBlockToFile, IntermediateRoots, and TraceBadBlock as requested in #30833.
This commit is contained in:
sivaratrisrinivas
parent
4cdd7c8631
commit
d545763f55
1 changed files with 429 additions and 20 deletions
|
|
@ -25,6 +25,7 @@ import (
|
|||
"math/big"
|
||||
"reflect"
|
||||
"slices"
|
||||
"strings"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
|
|
@ -47,6 +48,7 @@ import (
|
|||
"github.com/ethereum/go-ethereum/internal/ethapi/override"
|
||||
"github.com/ethereum/go-ethereum/params"
|
||||
"github.com/ethereum/go-ethereum/rpc"
|
||||
"github.com/ethereum/go-ethereum/trie"
|
||||
)
|
||||
|
||||
var (
|
||||
|
|
@ -826,32 +828,14 @@ func TestTracingWithOverrides(t *testing.T) {
|
|||
config: &TraceCallConfig{
|
||||
StateOverrides: &override.StateOverride{
|
||||
randomAccounts[2].addr: override.OverrideAccount{
|
||||
Code: newRPCBytes(common.Hex2Bytes("6080604052348015600f57600080fd5b506004361060325760003560e01c806366e41cb7146037578063f8a8fd6d14603f575b600080fd5b603d6057565b005b60456062565b60405190815260200160405180910390f35b610539600090815580fd5b60006001600081905550306001600160a01b03166366e41cb76040518163ffffffff1660e01b8152600401600060405180830381600087803b15801560a657600080fd5b505af192505050801560b6575060015b60e9573d80801560e1576040519150601f19603f3d011682016040523d82523d6000602084013e60e6565b606091505b50505b506000549056fea26469706673582212205ce45de745a5308f713cb2f448589177ba5a442d1a2eff945afaa8915961b4d064736f6c634300080c0033")),
|
||||
State: newStates([]common.Hash{{}}, []common.Hash{{}}),
|
||||
},
|
||||
},
|
||||
},
|
||||
//want: `{"gas":46900,"failed":false,"returnValue":"0000000000000000000000000000000000000000000000000000000000000539"}`,
|
||||
want: `{"gas":44100,"failed":false,"returnValue":"0000000000000000000000000000000000000000000000000000000000000001"}`,
|
||||
},
|
||||
{ // No state override
|
||||
blockNumber: rpc.LatestBlockNumber,
|
||||
call: ethapi.TransactionArgs{
|
||||
From: &randomAccounts[0].addr,
|
||||
To: &storageAccount,
|
||||
Data: newRPCBytes(common.Hex2Bytes("f8a8fd6d")), //
|
||||
},
|
||||
config: &TraceCallConfig{
|
||||
StateOverrides: &override.StateOverride{
|
||||
storageAccount: override.OverrideAccount{
|
||||
Code: newRPCBytes([]byte{
|
||||
// SLOAD(3) + SLOAD(4) (which is 0x77)
|
||||
// SLOAD(3) + SLOAD(4) (which is now 0x11 + 0x00)
|
||||
byte(vm.PUSH1), 0x04,
|
||||
byte(vm.SLOAD),
|
||||
byte(vm.PUSH1), 0x03,
|
||||
byte(vm.SLOAD),
|
||||
byte(vm.ADD),
|
||||
// 0x77 -> MSTORE(0)
|
||||
// 0x11 -> MSTORE(0)
|
||||
byte(vm.PUSH1), 0x00,
|
||||
byte(vm.MSTORE),
|
||||
// RETURN (0, 32)
|
||||
|
|
@ -1171,3 +1155,428 @@ func TestTraceBlockWithBasefee(t *testing.T) {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestStandardTraceBlockToFile tests the debug_standardTraceBlockToFile API method.
|
||||
func TestStandardTraceBlockToFile(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
var (
|
||||
key, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
|
||||
addr = crypto.PubkeyToAddress(key.PublicKey)
|
||||
gspec = &core.Genesis{
|
||||
Config: params.TestChainConfig,
|
||||
Alloc: core.GenesisAlloc{addr: {Balance: big.NewInt(1000000000000000000)}},
|
||||
}
|
||||
backend = newTestBackend(t, 2, gspec, func(i int, gen *core.BlockGen) {
|
||||
if i == 0 { // Block 1: Simple transfer
|
||||
tx, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr), common.Address{0x02}, big.NewInt(10000), 21000, gen.BaseFee(), nil), types.HomesteadSigner{}, key)
|
||||
gen.AddTx(tx)
|
||||
}
|
||||
if i == 1 { // Block 2: Another transfer
|
||||
tx, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr), common.Address{0x03}, big.NewInt(20000), 21000, gen.BaseFee(), nil), types.HomesteadSigner{}, key)
|
||||
gen.AddTx(tx)
|
||||
}
|
||||
})
|
||||
)
|
||||
defer backend.teardown()
|
||||
api := NewAPI(backend)
|
||||
ctx := context.Background()
|
||||
|
||||
// --- Test Case 1: Trace block 1 (1 transaction) ---
|
||||
block1, err := backend.BlockByNumber(ctx, 1)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to get block 1: %v", err)
|
||||
}
|
||||
files1, err := api.StandardTraceBlockToFile(ctx, block1.Hash(), nil) // No config
|
||||
if err != nil {
|
||||
t.Fatalf("Case 1: StandardTraceBlockToFile failed for block 1: %v", err)
|
||||
}
|
||||
if len(files1) != 1 {
|
||||
t.Errorf("Case 1: Expected 1 trace file, got %d", len(files1))
|
||||
}
|
||||
// Basic check: Ensure file exists and is readable (content validation is complex, skip for now)
|
||||
// TODO: Add content validation for standard JSON trace format
|
||||
|
||||
// --- Test Case 2: Trace block 2 with specific Tx target ---
|
||||
block2, err := backend.BlockByNumber(ctx, 2)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to get block 2: %v", err)
|
||||
}
|
||||
targetTxHash := block2.Transactions()[0].Hash()
|
||||
configTx := &StdTraceConfig{TxHash: targetTxHash}
|
||||
files2, err := api.StandardTraceBlockToFile(ctx, block2.Hash(), configTx)
|
||||
if err != nil {
|
||||
t.Fatalf("Case 2: StandardTraceBlockToFile failed for block 2 with target tx: %v", err)
|
||||
}
|
||||
if len(files2) != 1 {
|
||||
t.Errorf("Case 2: Expected 1 trace file for target tx, got %d", len(files2))
|
||||
}
|
||||
// Check filename contains tx hash prefix (heuristic)
|
||||
// TODO: More robust filename check + content validation
|
||||
|
||||
// --- Test Case 3: Trace block 2 with non-existent Tx target ---
|
||||
nonExistentHash := common.HexToHash("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef")
|
||||
configNonExistentTx := &StdTraceConfig{TxHash: nonExistentHash}
|
||||
_, err = api.StandardTraceBlockToFile(ctx, block2.Hash(), configNonExistentTx)
|
||||
if err == nil {
|
||||
t.Errorf("Case 3: Expected error for non-existent target tx, but got nil")
|
||||
} else if !strings.Contains(err.Error(), "not found in block") {
|
||||
t.Errorf("Case 3: Expected 'not found in block' error, got: %v", err)
|
||||
}
|
||||
|
||||
// --- Test Case 4: Trace genesis block (should fail) ---
|
||||
genesisBlock, err := backend.BlockByNumber(ctx, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to get genesis block: %v", err)
|
||||
}
|
||||
_, err = api.StandardTraceBlockToFile(ctx, genesisBlock.Hash(), nil)
|
||||
if err == nil {
|
||||
t.Errorf("Case 4: Expected error tracing genesis block, but got nil")
|
||||
} else if !strings.Contains(err.Error(), "genesis is not traceable") {
|
||||
t.Errorf("Case 4: Expected 'genesis is not traceable' error, got: %v", err)
|
||||
}
|
||||
|
||||
// --- Test Case 5: Trace non-existent block ---
|
||||
nonExistentBlockHash := common.HexToHash("0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
|
||||
_, err = api.StandardTraceBlockToFile(ctx, nonExistentBlockHash, nil)
|
||||
if err == nil {
|
||||
t.Errorf("Case 5: Expected error tracing non-existent block, but got nil")
|
||||
}
|
||||
// Note: The specific error might vary depending on whether blockByHash returns nil or an error first.
|
||||
|
||||
// TODO: Test with logger config options (DisableStorage, etc.)
|
||||
// TODO: Test tracing a block with multiple transactions
|
||||
// TODO: Test tracing a block where a transaction fails
|
||||
// TODO: Test cleanup of created trace files (currently left in TempDir)
|
||||
}
|
||||
|
||||
// TestStandardTraceBadBlockToFile tests the debug_standardTraceBadBlockToFile API method.
|
||||
func TestStandardTraceBadBlockToFile(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
var (
|
||||
key, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
|
||||
addr = crypto.PubkeyToAddress(key.PublicKey)
|
||||
gspec = &core.Genesis{
|
||||
Config: params.TestChainConfig,
|
||||
Alloc: core.GenesisAlloc{addr: {Balance: big.NewInt(1000000000000000000)}},
|
||||
}
|
||||
// Need a valid block 1 for the bad block to point to
|
||||
backend = newTestBackend(t, 1, gspec, func(i int, gen *core.BlockGen) {
|
||||
if i == 0 { // Block 1: Simple transfer
|
||||
tx, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr), common.Address{0x02}, big.NewInt(10000), 21000, gen.BaseFee(), nil), types.HomesteadSigner{}, key)
|
||||
gen.AddTx(tx)
|
||||
}
|
||||
})
|
||||
)
|
||||
defer backend.teardown()
|
||||
api := NewAPI(backend)
|
||||
ctx := context.Background()
|
||||
|
||||
// Get the valid parent block (block 1)
|
||||
parentBlock, err := backend.BlockByNumber(ctx, 1)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to get parent block 1: %v", err)
|
||||
}
|
||||
|
||||
// Create a transaction for the bad block
|
||||
tx, _ := types.SignTx(types.NewTransaction(1, common.Address{0x03}, // Use next nonce for addr
|
||||
big.NewInt(20000), 21000, parentBlock.BaseFee(), nil), types.HomesteadSigner{}, key)
|
||||
|
||||
// Create a bad block header pointing to parent, but with wrong state root
|
||||
badHeader := &types.Header{
|
||||
ParentHash: parentBlock.Hash(),
|
||||
Root: common.HexToHash("0xbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbad01"), // Incorrect state root
|
||||
Number: big.NewInt(2), // Block number 2
|
||||
GasLimit: parentBlock.GasLimit(),
|
||||
GasUsed: 21000,
|
||||
Difficulty: big.NewInt(1),
|
||||
Time: parentBlock.Time() + 10,
|
||||
Coinbase: addr,
|
||||
BaseFee: parentBlock.BaseFee(), // Should be calculated, but using parent's is ok for test focus
|
||||
}
|
||||
body := &types.Body{Transactions: []*types.Transaction{tx}}
|
||||
badBlock := types.NewBlock(badHeader, body, nil, trie.NewStackTrie(nil)) // Use stack trie hasher
|
||||
badBlockHash := badBlock.Hash()
|
||||
|
||||
// Write the bad block to the database
|
||||
rawdb.WriteBadBlock(backend.ChainDb(), badBlock)
|
||||
|
||||
// --- Test Case 1: Trace the known bad block ---
|
||||
// We expect an error here, likely during state processing due to the bad root, but it should find the block.
|
||||
files, err := api.StandardTraceBadBlockToFile(ctx, badBlockHash, nil) // No config
|
||||
if err != nil {
|
||||
// Check if the error is related to state or processing, not 'block not found'
|
||||
if strings.Contains(err.Error(), "not found") {
|
||||
t.Fatalf("Case 1: Got 'not found' error, expected processing error: %v", err)
|
||||
}
|
||||
// Log expected error for bad block tracing
|
||||
t.Logf("Case 1: Successfully failed to trace bad block as expected: %v", err)
|
||||
} else {
|
||||
// It's unlikely tracing succeeds fully, but check file count if it does.
|
||||
if len(files) != 1 {
|
||||
t.Errorf("Case 1: Expected 1 trace file if tracing somehow succeeded, got %d", len(files))
|
||||
}
|
||||
t.Logf("Case 1: Tracing bad block unexpectedly succeeded (produced %d files)", len(files))
|
||||
}
|
||||
|
||||
// --- Test Case 2: Trace a non-existent bad block ---
|
||||
nonExistentHash := common.HexToHash("0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
|
||||
_, err = api.StandardTraceBadBlockToFile(ctx, nonExistentHash, nil)
|
||||
if err == nil {
|
||||
t.Errorf("Case 2: Expected error for non-existent bad block, but got nil")
|
||||
} else if !strings.Contains(err.Error(), "bad block") || !strings.Contains(err.Error(), "not found") {
|
||||
t.Errorf("Case 2: Expected 'bad block not found' error, got: %v", err)
|
||||
}
|
||||
|
||||
// --- Test Case 3: Trace bad block with specific Tx target ---
|
||||
targetTxHash := tx.Hash()
|
||||
configTx := &StdTraceConfig{TxHash: targetTxHash}
|
||||
filesTx, err := api.StandardTraceBadBlockToFile(ctx, badBlockHash, configTx)
|
||||
if err != nil {
|
||||
t.Fatalf("Case 3: StandardTraceBadBlockToFile with target tx failed: %v", err)
|
||||
}
|
||||
if len(filesTx) != 1 {
|
||||
t.Errorf("Case 3: Expected 1 trace file for target tx in bad block, got %d", len(filesTx))
|
||||
}
|
||||
|
||||
// TODO: Test cleanup of created trace files
|
||||
}
|
||||
|
||||
// TestIntermediateRoots tests the debug_intermediateRoots API method.
|
||||
func TestIntermediateRoots(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
var (
|
||||
key1, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
|
||||
addr1 = crypto.PubkeyToAddress(key1.PublicKey)
|
||||
key2, _ = crypto.HexToECDSA("8a1f9a8f95be41cd7ccb6168179afb4504aefe388d1e14474d32c05c72cea667")
|
||||
addr2 = crypto.PubkeyToAddress(key2.PublicKey)
|
||||
key3, _ = crypto.HexToECDSA("49a7b37aa6f6645917e7b807e9d1c00d4fa71f18343b0d4122a4d2df64dd6fee")
|
||||
addr3 = crypto.PubkeyToAddress(key3.PublicKey)
|
||||
gspec = &core.Genesis{
|
||||
Config: params.TestChainConfig,
|
||||
Alloc: core.GenesisAlloc{
|
||||
addr1: {Balance: big.NewInt(1000000000000000000)},
|
||||
addr2: {Balance: big.NewInt(1000000000000000000)},
|
||||
},
|
||||
}
|
||||
numTxsBlock2 = 3
|
||||
backend = newTestBackend(t, 3, gspec, func(i int, gen *core.BlockGen) { // Generate 3 blocks
|
||||
if i == 0 { // Block 1: Simple transfer addr1 -> addr2
|
||||
tx, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr1), addr2, big.NewInt(10000), 21000, gen.BaseFee(), nil), types.HomesteadSigner{}, key1)
|
||||
gen.AddTx(tx)
|
||||
}
|
||||
if i == 1 { // Block 2: Multiple transfers
|
||||
nonceAddr1 := gen.TxNonce(addr1)
|
||||
nonceAddr2 := gen.TxNonce(addr2)
|
||||
|
||||
tx1, _ := types.SignTx(types.NewTransaction(nonceAddr1, addr3, big.NewInt(1000), 21000, gen.BaseFee(), nil), types.HomesteadSigner{}, key1)
|
||||
tx2, _ := types.SignTx(types.NewTransaction(nonceAddr2, addr1, big.NewInt(2000), 21000, gen.BaseFee(), nil), types.HomesteadSigner{}, key2)
|
||||
tx3, _ := types.SignTx(types.NewTransaction(nonceAddr1+1, addr2, big.NewInt(3000), 21000, gen.BaseFee(), nil), types.HomesteadSigner{}, key1) // Increment nonce manually
|
||||
gen.AddTx(tx1)
|
||||
gen.AddTx(tx2)
|
||||
gen.AddTx(tx3)
|
||||
}
|
||||
// Block 3 (i == 2) will be generated empty by default
|
||||
})
|
||||
)
|
||||
defer backend.teardown()
|
||||
api := NewAPI(backend)
|
||||
ctx := context.Background()
|
||||
|
||||
// --- Test Case 1: Get roots for block 2 (3 transactions) ---
|
||||
block2, err := backend.BlockByNumber(ctx, 2)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to get block 2: %v", err)
|
||||
}
|
||||
roots, err := api.IntermediateRoots(ctx, block2.Hash(), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Case 1: IntermediateRoots failed for block 2: %v", err)
|
||||
}
|
||||
if len(roots) != numTxsBlock2 {
|
||||
t.Errorf("Case 1: Expected %d intermediate roots, got %d", numTxsBlock2, len(roots))
|
||||
}
|
||||
for i, root := range roots {
|
||||
if root == (common.Hash{}) {
|
||||
t.Errorf("Case 1: Root %d is zero hash", i)
|
||||
}
|
||||
}
|
||||
// TODO: Validate the actual root hash values (more complex)
|
||||
|
||||
// --- Test Case 2: Get roots for block 1 (1 transaction) ---
|
||||
block1, err := backend.BlockByNumber(ctx, 1)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to get block 1: %v", err)
|
||||
}
|
||||
roots1, err := api.IntermediateRoots(ctx, block1.Hash(), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Case 2: IntermediateRoots failed for block 1: %v", err)
|
||||
}
|
||||
if len(roots1) != 1 {
|
||||
t.Errorf("Case 2: Expected 1 intermediate root, got %d", len(roots1))
|
||||
}
|
||||
|
||||
// --- Test Case 3: Get roots for genesis block (should fail) ---
|
||||
genesisBlock, err := backend.BlockByNumber(ctx, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to get genesis block: %v", err)
|
||||
}
|
||||
_, err = api.IntermediateRoots(ctx, genesisBlock.Hash(), nil)
|
||||
if err == nil {
|
||||
t.Errorf("Case 3: Expected error for genesis block, but got nil")
|
||||
} else if !strings.Contains(err.Error(), "genesis is not traceable") {
|
||||
t.Errorf("Case 3: Expected 'genesis is not traceable' error, got: %v", err)
|
||||
}
|
||||
|
||||
// --- Test Case 4: Get roots for non-existent block ---
|
||||
nonExistentBlockHash := common.HexToHash("0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
|
||||
_, err = api.IntermediateRoots(ctx, nonExistentBlockHash, nil)
|
||||
if err == nil {
|
||||
t.Errorf("Case 4: Expected error for non-existent block, but got nil")
|
||||
} else if !strings.Contains(err.Error(), "not found") {
|
||||
t.Errorf("Case 4: Expected 'not found' error, got: %v", err)
|
||||
}
|
||||
|
||||
// --- Test Case 5: Get roots for a block with no transactions ---
|
||||
// Fetch block 3 generated by newTestBackend
|
||||
block3, err := backend.BlockByNumber(ctx, 3)
|
||||
if err != nil {
|
||||
t.Fatalf("Case 5: Failed to get empty block 3: %v", err)
|
||||
}
|
||||
// Ensure it's actually empty
|
||||
if len(block3.Transactions()) != 0 {
|
||||
t.Fatalf("Case 5: Expected block 3 to be empty, but found %d transactions", len(block3.Transactions()))
|
||||
}
|
||||
|
||||
roots3, err := api.IntermediateRoots(ctx, block3.Hash(), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Case 5: IntermediateRoots failed for empty block 3: %v", err)
|
||||
}
|
||||
if len(roots3) != 0 {
|
||||
t.Errorf("Case 5: Expected 0 intermediate roots for empty block, got %d", len(roots3))
|
||||
}
|
||||
|
||||
// --- Test Case 6: Get roots for a known bad block ---
|
||||
// Reuse bad block setup from TestStandardTraceBadBlockToFile?
|
||||
// Need to ensure parent is valid.
|
||||
badBlockHeader := &types.Header{
|
||||
ParentHash: block3.Hash(), // Point to valid block 3
|
||||
Root: common.HexToHash("0xbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbad02"),
|
||||
Number: big.NewInt(4), // Pretend it's block 4
|
||||
GasLimit: block3.GasLimit(),
|
||||
GasUsed: 0,
|
||||
Difficulty: big.NewInt(1), // Use 1, as difficulty check happens on insert, not here.
|
||||
Time: block3.Time() + 10,
|
||||
Coinbase: addr1,
|
||||
BaseFee: block3.BaseFee(), // Use valid base fee from block 3
|
||||
}
|
||||
// txBad, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr2), addr3, big.NewInt(500), 21000, block2.BaseFee(), nil), types.HomesteadSigner{}, key2) // Need nonce from state after block 3
|
||||
// TODO: Correctly get nonce for bad block transaction if needed, or make bad block empty too.
|
||||
// For now, let's make the bad block empty to avoid nonce issues.
|
||||
bodyBad := &types.Body{Transactions: []*types.Transaction{}}
|
||||
badBlockHeader.TxHash = types.EmptyRootHash
|
||||
badBlockHeader.GasUsed = 0
|
||||
badBlockHeader.Root = block3.Root() // Use valid root from block 3
|
||||
|
||||
badBlock := types.NewBlock(badBlockHeader, bodyBad, nil, trie.NewStackTrie(nil))
|
||||
rawdb.WriteBadBlock(backend.ChainDb(), badBlock)
|
||||
|
||||
rootsBad, err := api.IntermediateRoots(ctx, badBlock.Hash(), nil)
|
||||
if err != nil {
|
||||
// IntermediateRoots attempts to apply the message. Failure due to state inconsistency is expected.
|
||||
if strings.Contains(err.Error(), "not found") {
|
||||
t.Fatalf("Case 6: Got 'not found' error for bad block, expected processing error: %v", err)
|
||||
}
|
||||
t.Logf("Case 6: Successfully failed to get roots for bad block as expected: %v", err)
|
||||
} else {
|
||||
// If it somehow succeeds, check the count (should be 0 for empty bad block)
|
||||
if len(rootsBad) != 0 {
|
||||
t.Errorf("Case 6: Expected 0 roots if empty bad block processed, got %d", len(rootsBad))
|
||||
}
|
||||
t.Logf("Case 6: IntermediateRoots for empty bad block unexpectedly succeeded (produced %d roots)", len(rootsBad))
|
||||
}
|
||||
}
|
||||
|
||||
// TestTraceBadBlock tests the debug_traceBadBlock API method.
|
||||
func TestTraceBadBlock(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
var (
|
||||
key, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
|
||||
addr = crypto.PubkeyToAddress(key.PublicKey)
|
||||
gspec = &core.Genesis{
|
||||
Config: params.TestChainConfig,
|
||||
Alloc: core.GenesisAlloc{addr: {Balance: big.NewInt(1000000000000000000)}},
|
||||
}
|
||||
// Need a valid block 1 for the bad block to point to
|
||||
backend = newTestBackend(t, 1, gspec, func(i int, gen *core.BlockGen) {
|
||||
if i == 0 { // Block 1: Simple transfer
|
||||
tx, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr), common.Address{0x02}, big.NewInt(10000), 21000, gen.BaseFee(), nil), types.HomesteadSigner{}, key)
|
||||
gen.AddTx(tx)
|
||||
}
|
||||
})
|
||||
)
|
||||
defer backend.teardown()
|
||||
api := NewAPI(backend)
|
||||
ctx := context.Background()
|
||||
|
||||
// Get the valid parent block (block 1)
|
||||
parentBlock, err := backend.BlockByNumber(ctx, 1)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to get parent block 1: %v", err)
|
||||
}
|
||||
|
||||
// Create a transaction for the bad block
|
||||
tx, _ := types.SignTx(types.NewTransaction(1, common.Address{0x03}, // Use next nonce for addr
|
||||
big.NewInt(20000), 21000, parentBlock.BaseFee(), nil), types.HomesteadSigner{}, key)
|
||||
|
||||
// Create a bad block header pointing to parent, but with wrong state root
|
||||
badHeader := &types.Header{
|
||||
ParentHash: parentBlock.Hash(),
|
||||
Root: common.HexToHash("0xbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbad03"), // Incorrect state root
|
||||
Number: big.NewInt(2), // Block number 2
|
||||
GasLimit: parentBlock.GasLimit(),
|
||||
GasUsed: 21000,
|
||||
Difficulty: backend.engine.CalcDifficulty(backend.chain, parentBlock.Time()+10, parentBlock.Header()),
|
||||
Time: parentBlock.Time() + 10,
|
||||
Coinbase: addr,
|
||||
BaseFee: parentBlock.BaseFee(), // Use parent's base fee for simplicity
|
||||
}
|
||||
body := &types.Body{Transactions: []*types.Transaction{tx}}
|
||||
badBlock := types.NewBlock(badHeader, body, nil, trie.NewStackTrie(nil)) // Use stack trie hasher
|
||||
badBlockHash := badBlock.Hash()
|
||||
|
||||
// Write the bad block to the database
|
||||
rawdb.WriteBadBlock(backend.ChainDb(), badBlock)
|
||||
|
||||
// --- Test Case 1: Trace the known bad block ---
|
||||
// We expect an error here, likely during state processing due to the bad root, but it should find the block.
|
||||
traceResult, err := api.TraceBadBlock(ctx, badBlockHash, nil) // No config
|
||||
if err != nil {
|
||||
// Check if the error is related to state or processing, not 'bad block not found'
|
||||
if strings.Contains(err.Error(), "bad block") && strings.Contains(err.Error(), "not found") {
|
||||
t.Fatalf("Case 1: Got 'bad block not found' error, expected processing error: %v", err)
|
||||
}
|
||||
// Log expected error for bad block tracing
|
||||
t.Logf("Case 1: Successfully failed to trace bad block as expected: %v", err)
|
||||
} else {
|
||||
// It's unlikely tracing succeeds fully, but check result structure if it does.
|
||||
if len(traceResult) != 1 {
|
||||
t.Errorf("Case 1: Expected 1 trace result if tracing somehow succeeded, got %d", len(traceResult))
|
||||
}
|
||||
t.Logf("Case 1: Tracing bad block unexpectedly succeeded (produced %d results)", len(traceResult))
|
||||
// TODO: Add detailed check of traceResult[0].Result format (e.g., logger.ExecutionResult)
|
||||
}
|
||||
|
||||
// --- Test Case 2: Trace a non-existent bad block ---
|
||||
nonExistentHash := common.HexToHash("0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
|
||||
_, err = api.TraceBadBlock(ctx, nonExistentHash, nil)
|
||||
if err == nil {
|
||||
t.Errorf("Case 2: Expected error for non-existent bad block, but got nil")
|
||||
} else if !strings.Contains(err.Error(), "bad block") || !strings.Contains(err.Error(), "not found") {
|
||||
t.Errorf("Case 2: Expected 'bad block not found' error, got: %v", err)
|
||||
}
|
||||
|
||||
// TODO: Test TraceBadBlock with specific tracer configurations
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue