Add support for Remix debugging of EVM call

Makefile

@@ -31,9 +31,9 @@ BINANCE_TGORACLE_DIR=$(GOPATH)/src/$(PKG_BINANCE_TGORACLE)
 #       specific commit.
 GO_LOOM_GIT_REV = HEAD
 # Specifies the loomnetwork/transfer-gateway branch/revision to use.
-TG_GIT_REV = HEAD
+TG_GIT_REV = config
 # loomnetwork/go-ethereum loomchain branch
-ETHEREUM_GIT_REV = 1fb6138d017a4309105d91f187c126cf979c93f9
+ETHEREUM_GIT_REV = ethapi
 # use go-plugin we get 'timeout waiting for connection info' error
 HASHICORP_GIT_REV = f4c3476bd38585f9ec669d10ed1686abd52b9961
 LEVIGO_GIT_REV = c42d9e0ca023e2198120196f842701bb4c55d7b9

app.go

@@ -7,44 +7,29 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/loomnetwork/loomchain/eth/utils"
-	"github.com/loomnetwork/loomchain/features"
-	"github.com/loomnetwork/loomchain/registry"
-
+	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/go-kit/kit/metrics"
 	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
 	cctypes "github.com/loomnetwork/go-loom/builtin/types/chainconfig"
+	"github.com/pkg/errors"
+
+	// "github.com/pkg/errors"
 	stdprometheus "github.com/prometheus/client_golang/prometheus"
 	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/libs/common"
 	ttypes "github.com/tendermint/tendermint/types"
 
+	"github.com/loomnetwork/loomchain/eth/utils"
+	"github.com/loomnetwork/loomchain/features"
+	"github.com/loomnetwork/loomchain/registry"
+	"github.com/loomnetwork/loomchain/txhandler"
+
 	"github.com/loomnetwork/loomchain/log"
 	appstate "github.com/loomnetwork/loomchain/state"
 	"github.com/loomnetwork/loomchain/store"
 	blockindex "github.com/loomnetwork/loomchain/store/block_index"
 	evmaux "github.com/loomnetwork/loomchain/store/evm_aux"
 )
 
-type TxHandler interface {
-	ProcessTx(state appstate.State, txBytes []byte, isCheckTx bool) (TxHandlerResult, error)
-}
-
-type TxHandlerFunc func(state appstate.State, txBytes []byte, isCheckTx bool) (TxHandlerResult, error)
-
-type TxHandlerResult struct {
-	Data             []byte
-	ValidatorUpdates []abci.Validator
-	Info             string
-	// Tags to associate with the tx that produced this result. Tags can be used to filter txs
-	// via the ABCI query interface (see https://godoc.org/github.com/tendermint/tendermint/libs/pubsub/query)
-	Tags []common.KVPair
-}
-
-func (f TxHandlerFunc) ProcessTx(state appstate.State, txBytes []byte, isCheckTx bool) (TxHandlerResult, error) {
-	return f(state, txBytes, isCheckTx)
-}
-
 type QueryHandler interface {
 	Handle(state appstate.ReadOnlyState, path string, data []byte) ([]byte, error)
 }
@@ -73,10 +58,11 @@ type Application struct {
 	curBlockHash    []byte
 	Store           store.VersionedKVStore
 	Init            func(appstate.State) error
-	TxHandler
+	txhandler.TxHandler
 	QueryHandler
 	EventHandler
 	ReceiptHandlerProvider
+	txhandler.TxHandlerFactory
 	EvmAuxStore *evmaux.EvmAuxStore
 	blockindex.BlockIndexStore
 	CreateValidatorManager   ValidatorsManagerFactoryFunc
@@ -89,6 +75,7 @@ type Application struct {
 	config                      *cctypes.Config
 	childTxRefs                 []evmaux.ChildTxRef // links Tendermint txs to EVM txs
 	ReceiptsVersion             int32
+	DebugTxHandler              txhandler.TxHandler
 }
 
 var _ abci.Application = &Application{}
@@ -304,13 +291,16 @@ func (a *Application) EndBlock(req abci.RequestEndBlock) abci.ResponseEndBlock {
 
 	// TODO: receiptHandler.CommitBlock() should be moved to Application.Commit()
 	storeTx := store.WrapAtomic(a.Store).BeginTx()
-	receiptHandler := a.ReceiptHandlerProvider.Store()
-	if err := receiptHandler.CommitBlock(a.height()); err != nil {
-		storeTx.Rollback()
-		// TODO: maybe panic instead?
-		log.Error(fmt.Sprintf("aborted committing block receipts, %v", err.Error()))
-	} else {
-		storeTx.Commit()
+
+	if a.ReceiptHandlerProvider != nil {
+		receiptHandler := a.ReceiptHandlerProvider.Store()
+		if err := receiptHandler.CommitBlock(a.height()); err != nil {
+			storeTx.Rollback()
+			// TODO: maybe panic instead?
+			log.Error(fmt.Sprintf("aborted committing block receipts, %v", err.Error()))
+		} else {
+			storeTx.Commit()
+		}
 	}
 
 	storeTx = store.WrapAtomic(a.Store).BeginTx()
@@ -438,7 +428,7 @@ func (a *Application) deliverTx(storeTx store.KVStoreTx, txBytes []byte) abci.Re
 	return abci.ResponseDeliverTx{Code: abci.CodeTypeOK, Data: r.Data, Tags: r.Tags, Info: r.Info}
 }
 
-func (a *Application) processTx(storeTx store.KVStoreTx, txBytes []byte, isCheckTx bool) (TxHandlerResult, error) {
+func (a *Application) processTx(storeTx store.KVStoreTx, txBytes []byte, isCheckTx bool) (txhandler.TxHandlerResult, error) {
 	state := appstate.NewStoreState(
 		context.Background(),
 		storeTx,
@@ -499,16 +489,17 @@ func (a *Application) deliverTx2(storeTx store.KVStoreTx, txBytes []byte) abci.R
 		a.curBlockHash,
 		a.GetValidatorSet,
 	).WithOnChainConfig(a.config)
-
-	receiptHandler := a.ReceiptHandlerProvider.Store()
-	defer receiptHandler.DiscardCurrentReceipt()
-	defer a.EventHandler.Rollback()
+	if a.ReceiptHandlerProvider != nil {
+		//receiptHandler := a.ReceiptHandlerProvider.Store()
+		defer a.ReceiptHandlerProvider.Store().DiscardCurrentReceipt()
+		defer a.EventHandler.Rollback()
+	}
 
 	r, txErr := a.TxHandler.ProcessTx(state, txBytes, false)
 
 	// Store the receipt even if the tx itself failed
 	var receiptTxHash []byte
-	if a.ReceiptHandlerProvider.Reader().GetCurrentReceipt() != nil {
+	if a.ReceiptHandlerProvider != nil && a.ReceiptHandlerProvider.Reader().GetCurrentReceipt() != nil {
 		receiptTxHash = a.ReceiptHandlerProvider.Reader().GetCurrentReceipt().TxHash
 		txHash := ttypes.Tx(txBytes).Hash()
 		// If a receipt was generated for an EVM tx add a link between the TM tx hash and the EVM tx hash
@@ -519,7 +510,7 @@ func (a *Application) deliverTx2(storeTx store.KVStoreTx, txBytes []byte) abci.R
 				ChildTxHash:  receiptTxHash,
 			})
 		}
-		receiptHandler.CommitCurrentReceipt()
+		a.ReceiptHandlerProvider.Store().CommitCurrentReceipt()
 	}
 
 	if txErr != nil {
@@ -530,13 +521,15 @@ func (a *Application) deliverTx2(storeTx store.KVStoreTx, txBytes []byte) abci.R
 		return abci.ResponseDeliverTx{Code: 1, Data: r.Data, Log: txErr.Error()}
 	}
 
-	a.EventHandler.Commit(uint64(a.curBlockHeader.GetHeight()))
 	storeTx.Commit()
 
-	// FIXME: Really shouldn't be sending out events until the whole block is committed because
-	//        the state changes from the tx won't be visible to queries until after Application.Commit()
-	if err := a.EventHandler.LegacyEthSubscriptionSet().EmitTxEvent(r.Data, r.Info); err != nil {
-		log.Error("Emit Tx Event error", "err", err)
+	if a.EventHandler != nil {
+		a.EventHandler.Commit(uint64(a.curBlockHeader.GetHeight()))
+		// FIXME: Really shouldn't be sending out events until the whole block is committed because
+		//        the state changes from the tx won't be visible to queries until after Application.Commit()
+		if err := a.EventHandler.LegacyEthSubscriptionSet().EmitTxEvent(r.Data, r.Info); err != nil {
+			log.Error("Emit Tx Event error", "err", err)
+		}
 	}
 
 	if len(receiptTxHash) > 0 {
@@ -563,23 +556,28 @@ func (a *Application) Commit() abci.ResponseCommit {
 
 	height := a.curBlockHeader.GetHeight()
 
-	if err := a.EvmAuxStore.SaveChildTxRefs(a.childTxRefs); err != nil {
-		// TODO: consider panic instead
-		log.Error("Failed to save Tendermint -> EVM tx hash refs", "height", height, "err", err)
+	if a.EvmAuxStore != nil {
+		if err := a.EvmAuxStore.SaveChildTxRefs(a.childTxRefs); err != nil {
+			// TODO: consider panic instead
+			log.Error("Failed to save Tendermint -> EVM tx hash refs", "height", height, "err", err)
+		}
 	}
 	a.childTxRefs = nil
 
-	go func(height int64, blockHeader abci.Header) {
-		if err := a.EventHandler.EmitBlockTx(uint64(height), blockHeader.Time); err != nil {
-			log.Error("Emit Block Event error", "err", err)
-		}
-		if err := a.EventHandler.LegacyEthSubscriptionSet().EmitBlockEvent(blockHeader); err != nil {
-			log.Error("Emit Block Event error", "err", err)
-		}
-		if err := a.EventHandler.EthSubscriptionSet().EmitBlockEvent(blockHeader); err != nil {
-			log.Error("Emit Block Event error", "err", err)
-		}
-	}(height, a.curBlockHeader)
+	if a.EventHandler != nil {
+		go func(height int64, blockHeader abci.Header) {
+			if err := a.EventHandler.EmitBlockTx(uint64(height), blockHeader.Time); err != nil {
+				log.Error("Emit Block Event error", "err", err)
+			}
+			if err := a.EventHandler.LegacyEthSubscriptionSet().EmitBlockEvent(blockHeader); err != nil {
+				log.Error("Emit Block Event error", "err", err)
+			}
+			if err := a.EventHandler.EthSubscriptionSet().EmitBlockEvent(blockHeader); err != nil {
+				log.Error("Emit Block Event error", "err", err)
+			}
+		}(height, a.curBlockHeader)
+	}
+
 	a.lastBlockHeader = a.curBlockHeader
 
 	if err := a.Store.Prune(); err != nil {
@@ -611,6 +609,7 @@ func (a *Application) Query(req abci.RequestQuery) abci.ResponseQuery {
 func (a *Application) height() int64 {
 	return a.Store.Version() + 1
 }
+
 func (a *Application) ReadOnlyState() appstate.State {
 	// TODO: the store snapshot should be created atomically, otherwise the block header might
 	//       not match the state... need to figure out why this hasn't spectacularly failed already
@@ -622,3 +621,53 @@ func (a *Application) ReadOnlyState() appstate.State {
 		a.GetValidatorSet,
 	)
 }
+
+func (a *Application) ReplayApplication(blockNumber uint64, blockstore store.BlockStore) (*Application, int64, error) {
+	startVersion := int64(blockNumber) - 1
+	if startVersion < 0 {
+		return nil, 0, errors.Errorf("invalid block number %d", blockNumber)
+	}
+	var snapshot store.Snapshot
+	for err := error(nil); (snapshot == nil || err != nil) && startVersion > 0; startVersion-- {
+		snapshot, err = a.Store.GetSnapshotAt(startVersion)
+	}
+	if startVersion == 0 {
+		return nil, 0, errors.Errorf("no saved version for height %d", blockNumber)
+	}
+
+	splitStore := store.NewSplitStore(snapshot, store.NewMemStore(), startVersion-1)
+	factory := a.TxHandlerFactory.Copy(splitStore)
+	txHandle, err := factory.TxHandler(nil, false)
+	if err != nil {
+		return nil, 0, err
+	}
+	newApp := &Application{
+		Store: splitStore,
+		Init: func(state appstate.State) error {
+			panic("init should not be called")
+		},
+		TxHandler:                   txHandle,
+		TxHandlerFactory:            factory,
+		BlockIndexStore:             nil,
+		EventHandler:                nil,
+		ReceiptHandlerProvider:      nil,
+		CreateValidatorManager:      a.CreateValidatorManager,
+		CreateChainConfigManager:    a.CreateChainConfigManager,
+		CreateContractUpkeepHandler: a.CreateContractUpkeepHandler,
+		EventStore:                  nil,
+		GetValidatorSet:             a.GetValidatorSet,
+		EvmAuxStore:                 nil,
+		ReceiptsVersion:             a.ReceiptsVersion,
+		config:                      a.config,
+	}
+	return newApp, startVersion, nil
+}
+
+func (a *Application) SetTracer(tracer vm.Tracer, metrics bool) error {
+	newTxHandle, err := a.TxHandlerFactory.TxHandler(tracer, metrics)
+	if err != nil {
+		return errors.Wrap(err, "making transaction handle")
+	}
+	a.TxHandler = newTxHandle
+	return nil
+}