[jsonrpc] Add debug_traceTransaction endpoint

jsonrpc/debug_endpoint.go

@@ -1 +1,169 @@
 package jsonrpc
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/dogechain-lab/dogechain/helper/hex"
+	"github.com/dogechain-lab/dogechain/state"
+	"github.com/dogechain-lab/dogechain/state/runtime"
+	"github.com/dogechain-lab/dogechain/state/tracer/structlogger"
+	"github.com/dogechain-lab/dogechain/types"
+)
+
+var (
+	ErrTransactionNotSeal         = errors.New("transaction not sealed")
+	ErrGenesisNotTracable         = errors.New("genesis is not traceable")
+	ErrTransactionNotFoundInBlock = errors.New("transaction not found in block")
+)
+
+type Debug struct {
+	store ethStore
+}
+
+func (d *Debug) TraceTransaction(hash types.Hash) (interface{}, error) {
+	// Check the chain state for the transaction
+	blockHash, ok := d.store.ReadTxLookup(hash)
+	if !ok {
+		// Block not found in storage
+		return nil, ErrBlockNotFound
+	}
+
+	block, ok := d.store.GetBlockByHash(blockHash, true)
+	if !ok {
+		// Block receipts not found in storage
+		return nil, ErrTransactionNotSeal
+	}
+	// It shouldn't happen in practice.
+	if block.Number() == 0 {
+		return nil, ErrGenesisNotTracable
+	}
+
+	var (
+		tx    *types.Transaction
+		txIdx = -1
+	)
+
+	// Find the transaction within the block
+	for idx, txn := range block.Transactions {
+		if txn.Hash == hash {
+			tx = txn
+			txIdx = idx
+
+			break
+		}
+	}
+
+	if txIdx < 0 {
+		// it shouldn't be
+		return nil, ErrTransactionNotFoundInBlock
+	}
+
+	txn, err := d.store.StateAtTransaction(block, txIdx)
+	if err != nil {
+		return nil, err
+	}
+
+	return d.traceTx(txn, tx)
+}
+
+func (d *Debug) traceTx(txn *state.Transition, tx *types.Transaction) (interface{}, error) {
+	var tracer runtime.EVMLogger = structlogger.NewStructLogger(txn.Txn())
+
+	txn.SetEVMLogger(tracer)
+
+	result, err := txn.Apply(tx)
+	if err != nil {
+		return nil, fmt.Errorf("tracing failed: %w", err)
+	}
+
+	switch tracer := tracer.(type) {
+	case *structlogger.StructLogger:
+		returnVal := fmt.Sprintf("%x", result.Return())
+		// If the result contains a revert reason, return it.
+		if result.Reverted() {
+			returnVal = fmt.Sprintf("%x", result.Revert())
+		}
+
+		return &ExecutionResult{
+			Gas:         result.GasUsed,
+			Failed:      result.Failed(),
+			ReturnValue: returnVal,
+			StructLogs:  formatLogs(tracer.StructLogs()),
+		}, nil
+	default:
+		panic(fmt.Sprintf("bad tracer type %T", tracer))
+	}
+}
+
+// ExecutionResult groups all structured logs emitted by the EVM
+// while replaying a transaction in debug mode as well as transaction
+// execution status, the amount of gas used and the return value
+type ExecutionResult struct {
+	Gas         uint64         `json:"gas"`
+	Failed      bool           `json:"failed"`
+	ReturnValue string         `json:"returnValue"`
+	StructLogs  []StructLogRes `json:"structLogs"`
+}
+
+// StructLogRes stores a structured log emitted by the EVM while replaying a
+// transaction in debug mode
+type StructLogRes struct {
+	Pc      uint64             `json:"pc"`
+	Op      string             `json:"op"`
+	Gas     uint64             `json:"gas"`
+	GasCost uint64             `json:"gasCost"`
+	Depth   int                `json:"depth"`
+	Error   string             `json:"error,omitempty"`
+	Stack   *[]string          `json:"stack,omitempty"`
+	Memory  *[]string          `json:"memory,omitempty"`
+	Storage *map[string]string `json:"storage,omitempty"`
+}
+
+// formatLogs formats EVM returned structured logs for json output
+func formatLogs(logs []*structlogger.StructLog) []StructLogRes {
+	formatted := make([]StructLogRes, len(logs))
+
+	for index, trace := range logs {
+		trace.OpName = trace.GetOpName()
+		trace.ErrorString = trace.GetErrorString()
+
+		formatted[index] = StructLogRes{
+			Pc:      trace.Pc,
+			Op:      trace.OpName,
+			Gas:     trace.Gas,
+			GasCost: trace.GasCost,
+			Depth:   trace.Depth,
+			Error:   trace.ErrorString,
+		}
+
+		if trace.Stack != nil {
+			stack := make([]string, len(trace.Stack))
+			for i, stackValue := range trace.Stack {
+				stack[i] = hex.EncodeBig(stackValue)
+			}
+
+			formatted[index].Stack = &stack
+		}
+
+		if len(trace.Memory) > 0 {
+			memory := make([]string, 0, (len(trace.Memory)+31)/32)
+			for i := 0; i+32 <= len(trace.Memory); i += 32 {
+				memory = append(memory, hex.EncodeToString(trace.Memory[i:i+32]))
+			}
+
+			formatted[index].Memory = &memory
+		}
+
+		if len(trace.Storage) > 0 {
+			storage := make(map[string]string)
+			for addr, val := range trace.Storage {
+				storage[hex.EncodeToString(addr.Bytes())] = hex.EncodeToString(val.Bytes())
+			}
+
+			formatted[index].Storage = &storage
+		}
+	}
+
+	return formatted
+}

jsonrpc/debug_endpoint_test.go

@@ -0,0 +1,199 @@
+package jsonrpc
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/dogechain-lab/dogechain/helper/hex"
+	"github.com/dogechain-lab/dogechain/state/runtime/evm"
+	"github.com/dogechain-lab/dogechain/state/tracer/structlogger"
+	"github.com/dogechain-lab/dogechain/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestDebug_FormatLogs(t *testing.T) {
+	//nolint:lll
+	var (
+		stackPc121 = []string{
+			"0x1ab06ee5",
+			"0x55",
+			"0x4",
+			"0x5",
+			"0x4",
+			"0x0",
+		}
+		stackPc122 = []string{
+			"0x1ab06ee5",
+			"0x55",
+			"0x4",
+			"0x5",
+			"0x4",
+			"0x0",
+			"0x4",
+		}
+		stackPc123 = []string{
+			"0x1ab06ee5",
+			"0x55",
+			"0x4",
+			"0x5",
+			"0x4",
+			"0x4",
+			"0x0",
+		}
+		stackPc124 = []string{
+			"0x1ab06ee5",
+			"0x55",
+			"0x4",
+			"0x5",
+			"0x4",
+		}
+		storagePc123 = map[string]string{
+			"0000000000000000000000000000000000000000000000000000000000000000": "0000000000000000000000000000000000000000000000000000000000000004",
+		}
+		memoryBytesPc124, _ = hex.DecodeHex("0000000000000000000000000000000000000000000000000000000000000000" +
+			"0000000000000000000000000000000000000000000000000000000000000000" +
+			"0000000000000000000000000000000000000000000000000000000000000080")
+		memoryPc124 = []string{
+			"0000000000000000000000000000000000000000000000000000000000000000",
+			"0000000000000000000000000000000000000000000000000000000000000000",
+			"0000000000000000000000000000000000000000000000000000000000000080",
+		}
+	)
+
+	tests := []struct {
+		name   string
+		input  []*structlogger.StructLog
+		result []StructLogRes
+	}{
+		{
+			name: "Stack should format right",
+			input: []*structlogger.StructLog{
+				{
+					Pc:      121,
+					Op:      evm.DUP1 + 1, // DUP2
+					Gas:     40035,
+					GasCost: 3,
+					Depth:   1,
+					Stack: []*big.Int{
+						new(big.Int).SetUint64(0x1ab06ee5),
+						new(big.Int).SetUint64(0x55),
+						new(big.Int).SetUint64(0x4),
+						new(big.Int).SetUint64(0x5),
+						new(big.Int).SetUint64(0x4),
+						new(big.Int).SetUint64(0x0),
+					},
+				},
+				{
+					Pc:      122,
+					Op:      evm.SWAP1,
+					Gas:     40032,
+					GasCost: 3,
+					Depth:   1,
+					Stack: []*big.Int{
+						new(big.Int).SetUint64(0x1ab06ee5),
+						new(big.Int).SetUint64(0x55),
+						new(big.Int).SetUint64(0x4),
+						new(big.Int).SetUint64(0x5),
+						new(big.Int).SetUint64(0x4),
+						new(big.Int).SetUint64(0x0),
+						new(big.Int).SetUint64(0x4),
+					},
+				},
+			},
+			result: []StructLogRes{
+				{
+					Pc:      121,
+					Op:      evm.OpCode(evm.DUP1 + 1).String(), // DUP2
+					Gas:     40035,
+					GasCost: 3,
+					Depth:   1,
+					Stack:   &stackPc121,
+				},
+				{
+					Pc:      122,
+					Op:      evm.OpCode(evm.SWAP1).String(),
+					Gas:     40032,
+					GasCost: 3,
+					Depth:   1,
+					Stack:   &stackPc122,
+				},
+			},
+		},
+		{
+			name: "Storage should format right",
+			input: []*structlogger.StructLog{
+				{
+					Pc:      123,
+					Op:      evm.SSTORE,
+					Gas:     40029,
+					GasCost: 20000,
+					Depth:   1,
+					Stack: []*big.Int{
+						new(big.Int).SetUint64(0x1ab06ee5),
+						new(big.Int).SetUint64(0x55),
+						new(big.Int).SetUint64(0x4),
+						new(big.Int).SetUint64(0x5),
+						new(big.Int).SetUint64(0x4),
+						new(big.Int).SetUint64(0x4),
+						new(big.Int).SetUint64(0x0),
+					},
+					Storage: map[types.Hash]types.Hash{
+						types.StringToHash("0x0"): types.StringToHash("0x4"),
+					},
+				},
+			},
+			result: []StructLogRes{
+				{
+					Pc:      123,
+					Op:      evm.OpCode(evm.SSTORE).String(),
+					Gas:     40029,
+					GasCost: 20000,
+					Depth:   1,
+					Stack:   &stackPc123,
+					Storage: &storagePc123,
+				},
+			},
+		},
+		{
+			name: "Memory should format right",
+			input: []*structlogger.StructLog{
+				{
+					Pc:      124,
+					Op:      evm.POP,
+					Gas:     20029,
+					GasCost: 2,
+					Depth:   1,
+					Stack: []*big.Int{
+						new(big.Int).SetUint64(0x1ab06ee5),
+						new(big.Int).SetUint64(0x55),
+						new(big.Int).SetUint64(0x4),
+						new(big.Int).SetUint64(0x5),
+						new(big.Int).SetUint64(0x4),
+					},
+					Memory: memoryBytesPc124,
+				},
+			},
+			result: []StructLogRes{
+				{
+					Pc:      124,
+					Op:      evm.OpCode(evm.POP).String(),
+					Gas:     20029,
+					GasCost: 2,
+					Depth:   1,
+					Stack:   &stackPc124,
+					Memory:  &memoryPc124,
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// format it
+			v := formatLogs(tt.input)
+
+			// Assert equality
+			assert.Equal(t, tt.result, v)
+		})
+	}
+}

jsonrpc/dispatcher.go

@@ -34,6 +34,7 @@ type endpoints struct {
 	Web3   *Web3
 	Net    *Net
 	TxPool *TxPool
+	Debug  *Debug
 }
 
 // Dispatcher handles all json rpc requests by delegating
@@ -84,11 +85,13 @@ func (d *Dispatcher) registerEndpoints(store JSONRPCStore) {
 	d.endpoints.Net = &Net{store, d.chainID}
 	d.endpoints.Web3 = &Web3{}
 	d.endpoints.TxPool = &TxPool{store}
+	d.endpoints.Debug = &Debug{store}
 
 	d.registerService("eth", d.endpoints.Eth)
 	d.registerService("net", d.endpoints.Net)
 	d.registerService("web3", d.endpoints.Web3)
 	d.registerService("txpool", d.endpoints.TxPool)
+	d.registerService("debug", d.endpoints.Debug)
 }
 
 func (d *Dispatcher) getFnHandler(req Request) (*serviceData, *funcData, Error) {