erigon-pulse/cmd/rpcdaemon/commands/debug_api_test.go

195 lines
7.2 KiB
Go
Raw Normal View History

package commands
import (
"bytes"
"context"
"encoding/json"
"testing"
jsoniter "github.com/json-iterator/go"
2021-09-29 01:36:25 +00:00
"github.com/ledgerwatch/erigon-lib/kv/kvcache"
2021-06-29 10:00:22 +00:00
"github.com/ledgerwatch/erigon/cmd/rpcdaemon/rpcdaemontest"
"github.com/ledgerwatch/erigon/common"
"github.com/ledgerwatch/erigon/eth/tracers"
"github.com/ledgerwatch/erigon/rpc"
"github.com/ledgerwatch/erigon/rpc/rpccfg"
"github.com/ledgerwatch/erigon/turbo/adapter/ethapi"
2021-11-14 04:08:52 +00:00
"github.com/ledgerwatch/erigon/turbo/snapshotsync"
)
var debugTraceTransactionTests = []struct {
txHash string
gas uint64
failed bool
returnValue string
}{
{"3f3cb8a0e13ed2481f97f53f7095b9cbc78b6ffb779f2d3e565146371a8830ea", 21000, false, ""},
2021-03-17 16:49:02 +00:00
{"f588c6426861d9ad25d5ccc12324a8d213f35ef1ed4153193f0c13eb81ca7f4a", 49189, false, "0000000000000000000000000000000000000000000000000000000000000001"},
{"b6449d8e167a8826d050afe4c9f07095236ff769a985f02649b1023c2ded2059", 38899, false, ""},
}
var debugTraceTransactionNoRefundTests = []struct {
txHash string
gas uint64
failed bool
returnValue string
}{
{"3f3cb8a0e13ed2481f97f53f7095b9cbc78b6ffb779f2d3e565146371a8830ea", 21000, false, ""},
2021-03-17 16:49:02 +00:00
{"f588c6426861d9ad25d5ccc12324a8d213f35ef1ed4153193f0c13eb81ca7f4a", 49189, false, "0000000000000000000000000000000000000000000000000000000000000001"},
{"b6449d8e167a8826d050afe4c9f07095236ff769a985f02649b1023c2ded2059", 62899, false, ""},
}
func TestTraceBlockByNumber(t *testing.T) {
m, _, _ := rpcdaemontest.CreateTestSentry(t)
agg := m.HistoryV3Components()
2022-10-18 04:53:54 +00:00
br := snapshotsync.NewBlockReaderWithSnapshots(m.BlockSnapshots)
stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
2022-10-18 04:53:54 +00:00
baseApi := NewBaseApi(nil, stateCache, br, agg, false, rpccfg.DefaultEvmCallTimeout)
ethApi := NewEthAPI(baseApi, m.DB, nil, nil, nil, 5000000)
api := NewPrivateDebugAPI(baseApi, m.DB, 0)
for _, tt := range debugTraceTransactionTests {
var buf bytes.Buffer
stream := jsoniter.NewStream(jsoniter.ConfigDefault, &buf, 4096)
tx, err := ethApi.GetTransactionByHash(context.Background(), common.HexToHash(tt.txHash))
if err != nil {
t.Errorf("traceBlock %s: %v", tt.txHash, err)
}
txcount, err := ethApi.GetBlockTransactionCountByHash(context.Background(), *tx.BlockHash)
if err != nil {
t.Errorf("traceBlock %s: %v", tt.txHash, err)
}
err = api.TraceBlockByNumber(context.Background(), rpc.BlockNumber(tx.BlockNumber.ToInt().Uint64()), &tracers.TraceConfig{}, stream)
if err != nil {
t.Errorf("traceBlock %s: %v", tt.txHash, err)
}
if err = stream.Flush(); err != nil {
t.Fatalf("error flusing: %v", err)
}
var er []ethapi.ExecutionResult
if err = json.Unmarshal(buf.Bytes(), &er); err != nil {
t.Fatalf("parsing result: %v", err)
}
if len(er) != int(*txcount) {
t.Fatalf("incorrect length: %v", err)
}
}
var buf bytes.Buffer
stream := jsoniter.NewStream(jsoniter.ConfigDefault, &buf, 4096)
err := api.TraceBlockByNumber(context.Background(), rpc.LatestBlockNumber, &tracers.TraceConfig{}, stream)
if err != nil {
t.Errorf("traceBlock %v: %v", rpc.LatestBlockNumber, err)
}
if err = stream.Flush(); err != nil {
t.Fatalf("error flusing: %v", err)
}
var er []ethapi.ExecutionResult
if err = json.Unmarshal(buf.Bytes(), &er); err != nil {
t.Fatalf("parsing result: %v", err)
}
}
func TestTraceBlockByHash(t *testing.T) {
m, _, _ := rpcdaemontest.CreateTestSentry(t)
agg := m.HistoryV3Components()
2022-10-18 04:53:54 +00:00
br := snapshotsync.NewBlockReaderWithSnapshots(m.BlockSnapshots)
stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
2022-10-18 04:53:54 +00:00
baseApi := NewBaseApi(nil, stateCache, br, agg, false, rpccfg.DefaultEvmCallTimeout)
ethApi := NewEthAPI(baseApi, m.DB, nil, nil, nil, 5000000)
api := NewPrivateDebugAPI(baseApi, m.DB, 0)
for _, tt := range debugTraceTransactionTests {
var buf bytes.Buffer
stream := jsoniter.NewStream(jsoniter.ConfigDefault, &buf, 4096)
tx, err := ethApi.GetTransactionByHash(m.Ctx, common.HexToHash(tt.txHash))
if err != nil {
t.Errorf("traceBlock %s: %v", tt.txHash, err)
}
txcount, err := ethApi.GetBlockTransactionCountByHash(m.Ctx, *tx.BlockHash)
if err != nil {
t.Errorf("traceBlock %s: %v", tt.txHash, err)
}
err = api.TraceBlockByHash(m.Ctx, *tx.BlockHash, &tracers.TraceConfig{}, stream)
if err != nil {
t.Errorf("traceBlock %s: %v", tt.txHash, err)
}
if err = stream.Flush(); err != nil {
t.Fatalf("error flusing: %v", err)
}
var er []ethapi.ExecutionResult
if err = json.Unmarshal(buf.Bytes(), &er); err != nil {
t.Fatalf("parsing result: %v", err)
}
if len(er) != int(*txcount) {
t.Fatalf("incorrect length: %v", err)
}
}
}
func TestTraceTransaction(t *testing.T) {
m, _, _ := rpcdaemontest.CreateTestSentry(t)
agg := m.HistoryV3Components()
2022-10-18 04:53:54 +00:00
br := snapshotsync.NewBlockReaderWithSnapshots(m.BlockSnapshots)
2021-09-29 01:36:25 +00:00
stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
2021-11-14 04:08:52 +00:00
api := NewPrivateDebugAPI(
2022-10-18 04:53:54 +00:00
NewBaseApi(nil, stateCache, br, agg, false, rpccfg.DefaultEvmCallTimeout),
m.DB, 0)
for _, tt := range debugTraceTransactionTests {
var buf bytes.Buffer
stream := jsoniter.NewStream(jsoniter.ConfigDefault, &buf, 4096)
err := api.TraceTransaction(context.Background(), common.HexToHash(tt.txHash), &tracers.TraceConfig{}, stream)
if err != nil {
t.Errorf("traceTransaction %s: %v", tt.txHash, err)
}
if err = stream.Flush(); err != nil {
t.Fatalf("error flusing: %v", err)
}
var er ethapi.ExecutionResult
if err = json.Unmarshal(buf.Bytes(), &er); err != nil {
t.Fatalf("parsing result: %v", err)
}
if er.Gas != tt.gas {
t.Errorf("wrong gas for transaction %s, got %d, expected %d", tt.txHash, er.Gas, tt.gas)
}
if er.Failed != tt.failed {
t.Errorf("wrong failed flag for transaction %s, got %t, expected %t", tt.txHash, er.Failed, tt.failed)
}
if er.ReturnValue != tt.returnValue {
t.Errorf("wrong return value for transaction %s, got %s, expected %s", tt.txHash, er.ReturnValue, tt.returnValue)
}
}
}
func TestTraceTransactionNoRefund(t *testing.T) {
m, _, _ := rpcdaemontest.CreateTestSentry(t)
2022-10-18 04:53:54 +00:00
br := snapshotsync.NewBlockReaderWithSnapshots(m.BlockSnapshots)
agg := m.HistoryV3Components()
2021-09-29 01:36:25 +00:00
stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
2021-11-14 04:08:52 +00:00
api := NewPrivateDebugAPI(
2022-10-18 04:53:54 +00:00
NewBaseApi(nil, stateCache, br, agg, false, rpccfg.DefaultEvmCallTimeout),
m.DB, 0)
for _, tt := range debugTraceTransactionNoRefundTests {
var buf bytes.Buffer
stream := jsoniter.NewStream(jsoniter.ConfigDefault, &buf, 4096)
var norefunds = true
err := api.TraceTransaction(context.Background(), common.HexToHash(tt.txHash), &tracers.TraceConfig{NoRefunds: &norefunds}, stream)
if err != nil {
t.Errorf("traceTransaction %s: %v", tt.txHash, err)
}
if err = stream.Flush(); err != nil {
t.Fatalf("error flusing: %v", err)
}
var er ethapi.ExecutionResult
if err = json.Unmarshal(buf.Bytes(), &er); err != nil {
t.Fatalf("parsing result: %v", err)
}
if er.Gas != tt.gas {
t.Errorf("wrong gas for transaction %s, got %d, expected %d", tt.txHash, er.Gas, tt.gas)
}
if er.Failed != tt.failed {
t.Errorf("wrong failed flag for transaction %s, got %t, expected %t", tt.txHash, er.Failed, tt.failed)
}
if er.ReturnValue != tt.returnValue {
t.Errorf("wrong return value for transaction %s, got %s, expected %s", tt.txHash, er.ReturnValue, tt.returnValue)
}
}
}