Add support for Remix debugging of EVM call

Jenkinsfile-PR.groovy

@@ -128,7 +128,7 @@ disabled['windows'] = {
   }
 }
 
-builders['osx'] = {
+disabled['osx'] = {
   node('osx-any') {
     timestamps {
       def thisBuild = null

app.go

@@ -3,22 +3,25 @@ package loomchain
 import (
 	"bytes"
 	"context"
+	"encoding/hex"
 	"fmt"
 	"time"
 
 	"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"
 	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/replay"
 	"github.com/loomnetwork/loomchain/txhandler"
-	"github.com/loomnetwork/loomchain/txhandler/middleware"
 
 	"github.com/loomnetwork/loomchain/log"
 	appstate "github.com/loomnetwork/loomchain/state"
@@ -368,7 +371,7 @@ func (a *Application) CheckTx(txBytes []byte) abci.ResponseCheckTx {
 
 	_, err = a.TxHandler.ProcessTx(state, txBytes, true)
 	if err != nil {
-		log.Error("CheckTx", "tx", ttypes.Tx(txBytes).Hash(), "err", err)
+		log.Error("CheckTx", "tx", hex.EncodeToString(ttypes.Tx(txBytes).Hash()), "err", err)
 		return abci.ResponseCheckTx{Code: 1, Log: err.Error()}
 	}
 
@@ -416,7 +419,7 @@ func (a *Application) DeliverTx(txBytes []byte) abci.ResponseDeliverTx {
 func (a *Application) deliverTx(storeTx store.KVStoreTx, txBytes []byte) abci.ResponseDeliverTx {
 	r, err := a.processTx(storeTx, txBytes, false)
 	if err != nil {
-		log.Error("DeliverTx", "tx", ttypes.Tx(txBytes).Hash(), "err", err)
+		log.Error("DeliverTx", "tx", hex.EncodeToString(ttypes.Tx(txBytes).Hash()), "err", err)
 		return abci.ResponseDeliverTx{Code: 1, Log: err.Error()}
 	}
 	return abci.ResponseDeliverTx{Code: abci.CodeTypeOK, Data: r.Data, Tags: r.Tags, Info: r.Info}
@@ -507,7 +510,7 @@ func (a *Application) deliverTx2(storeTx store.KVStoreTx, txBytes []byte) abci.R
 	}
 
 	if txErr != nil {
-		log.Error("DeliverTx", "tx", ttypes.Tx(txBytes).Hash(), "err", txErr)
+		log.Error("DeliverTx", "tx", hex.EncodeToString(ttypes.Tx(txBytes).Hash()), "err", txErr)
 		// FIXME: Really shouldn't be using r.Data if txErr != nil, but need to refactor TxHandler.ProcessTx
 		//        so it only returns r with the correct status code & log fields.
 		// Pass the EVM tx hash (if any) back to Tendermint so it stores it in block results
@@ -595,41 +598,45 @@ 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
 	return appstate.NewStoreStateSnapshot(
 		nil,
-		a.Store.GetSnapshot(),
+		a.Store.GetSnapshot(0),
 		a.lastBlockHeader,
 		nil, // TODO: last block hash!
 		a.GetValidatorSet,
 	)
 }
 
-func (a *Application) InMemoryApp(blockNumber uint64, blockstore store.BlockStore) (middleware.InMemoryApp, error) {
-	startVersion := int64(blockNumber) - 1
+func (a *Application) ReplayApplication(blockNumber uint64, blockstore store.BlockStore) (replay.ReplayApplication, int64, error) {
+	startVersion := int64(blockNumber)
 	if startVersion < 0 {
-		return nil, errors.Errorf("invalid block number %d", blockNumber)
+		return nil, 0, errors.Errorf("invalid block number %d", blockNumber)
 	}
-	for ; !a.Store.VersionExists(startVersion) || startVersion <= int64(0); startVersion-- {
+	var snapshot store.Snapshot
+	for ; snapshot == nil && startVersion > 0; snapshot = a.Store.GetSnapshot(startVersion) {
+		startVersion--
 	}
 	if startVersion == 0 {
-		return nil, errors.Errorf("no saved version for height %d", blockNumber)
-	}
-	startStore, err := a.Store.RetrieveVersion(startVersion)
-	if err != nil {
-		return nil, err
+		return nil, 0, errors.Errorf("no saved version for height %d", blockNumber)
 	}
 
-	return middleware.NewInMemoryApp(
+	startStore := store.NewSplitStore(snapshot, store.NewMemStore())
+	newApp, err := replay.NewReplayApplication(
 		startVersion,
 		blockstore,
 		startStore,
-		a.TxHandler,
 		a.ReceiptsVersion,
 		a.GetValidatorSet,
 		a.config,
 		a.TxHandlerFactory,
-	), nil
+		nil,
+	)
+	if err != nil {
+		return nil, 0, err
+	}
+	return newApp, startVersion, nil
 }

auth/eth.go

@@ -3,12 +3,20 @@
 package auth
 
 import (
+	"bytes"
+
+	etypes "github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/rlp"
+	"github.com/golang/protobuf/proto"
+	"github.com/loomnetwork/go-loom/auth"
 	"github.com/loomnetwork/go-loom/common/evmcompat"
+	"github.com/loomnetwork/go-loom/types"
+	"github.com/loomnetwork/go-loom/vm"
 	sha3 "github.com/miguelmota/go-solidity-sha3"
 	"github.com/pkg/errors"
 )
 
-func verifySolidity66Byte(tx SignedTx, allowSigTypes []evmcompat.SignatureType) ([]byte, error) {
+func verifySolidity66Byte(chainID string, tx SignedTx, allowSigTypes []evmcompat.SignatureType) ([]byte, error) {
 	ethAddr, err := evmcompat.RecoverAddressFromTypedSig(sha3.SoliditySHA3(tx.Inner), tx.Signature, allowSigTypes)
 	if err != nil {
 		return nil, errors.Wrap(err, "verify solidity key")
@@ -17,18 +25,69 @@ func verifySolidity66Byte(tx SignedTx, allowSigTypes []evmcompat.SignatureType)
 	return ethAddr.Bytes(), nil
 }
 
-func verifyTron(tx SignedTx, allowSigTypes []evmcompat.SignatureType) ([]byte, error) {
+func verifyTron(chainID string, tx SignedTx, allowSigTypes []evmcompat.SignatureType) ([]byte, error) {
 	tronAddr, err := evmcompat.RecoverAddressFromTypedSig(sha3.SoliditySHA3(tx.Inner), tx.Signature, allowSigTypes)
 	if err != nil {
 		return nil, err
 	}
 	return tronAddr.Bytes(), nil
 }
 
-func verifyBinance(tx SignedTx, allowSigTypes []evmcompat.SignatureType) ([]byte, error) {
+func verifyBinance(chainID string, tx SignedTx, allowSigTypes []evmcompat.SignatureType) ([]byte, error) {
 	addr, err := evmcompat.RecoverAddressFromTypedSig(evmcompat.GenSHA256(tx.Inner), tx.Signature, allowSigTypes)
 	if err != nil {
 		return nil, err
 	}
 	return addr.Bytes(), nil
 }
+
+func VerifyWrappedEthTx(chainID string, signedTx SignedTx, _ []evmcompat.SignatureType) ([]byte, error) {
+	if len(signedTx.Signature) != 0 {
+		return nil, errors.New("unexpected signature in SignedTx")
+	}
+
+	var nonceTx auth.NonceTx
+	if err := proto.Unmarshal(signedTx.Inner, &nonceTx); err != nil {
+		return nil, err
+	}
+
+	var loomTx types.Transaction
+	if err := proto.Unmarshal(nonceTx.Inner, &loomTx); err != nil {
+		return nil, err
+	}
+
+	var msgTx vm.MessageTx
+	if err := proto.Unmarshal(loomTx.Data, &msgTx); err != nil {
+		return nil, err
+	}
+
+	var ethTx etypes.Transaction
+	if err := rlp.DecodeBytes(msgTx.Data, &ethTx); err != nil {
+		return nil, errors.Wrap(err, "failed to decode EthereumTx")
+	}
+
+	if ethTx.To() != nil && !bytes.Equal(ethTx.To().Bytes(), msgTx.To.Local) {
+		return nil, errors.Errorf(
+			"EthereumTx.To (%s) doesn't match MessageTx.To (%s)",
+			ethTx.To().String(), msgTx.To.String(),
+		)
+	}
+	if ethTx.Nonce() != nonceTx.Sequence {
+		return nil, errors.Errorf(
+			"EthereumTx.Nonce (%d) doesn't match NonceTx.Sequence (%d)",
+			ethTx.Nonce(), nonceTx.Sequence,
+		)
+	}
+
+	ethChainID, err := evmcompat.ToEthereumChainID(chainID)
+	if err != nil {
+		return nil, err
+	}
+	ethSigner := etypes.NewEIP155Signer(ethChainID)
+	from, err := etypes.Sender(ethSigner, &ethTx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to recover signer from EthereumTx")
+	}
+
+	return from.Bytes(), err
+}

auth/multi_chain_sigtx_middleware.go

@@ -7,7 +7,7 @@ import (
 	"fmt"
 
 	"github.com/gogo/protobuf/proto"
-	"github.com/loomnetwork/go-loom"
+	loom "github.com/loomnetwork/go-loom"
 	"github.com/loomnetwork/go-loom/common/evmcompat"
 	"github.com/loomnetwork/go-loom/plugin/contractpb"
 	"github.com/loomnetwork/go-loom/types"
@@ -22,14 +22,20 @@ import (
 	"github.com/loomnetwork/loomchain/txhandler"
 )
 
-var originRecoveryFuncs = map[keys.SignedTxType]originRecoveryFunc{
-	keys.LoomSignedTxType:     verifyEd25519,
-	keys.EthereumSignedTxType: verifySolidity66Byte,
-	keys.TronSignedTxType:     verifyTron,
-	keys.BinanceSignedTxType:  verifyBinance,
-}
+// AccountType is used to specify which address should be used on-chain to identify a tx sender.
+type AccountType int
+
+const (
+	// NativeAccountType indicates that the tx sender address should be passed through to contracts
+	// as is, with the original chain ID intact.
+	NativeAccountType AccountType = iota
+	// MappedAccountType indicates that the tx sender address should be mapped to a DAppChain
+	// address before being passed through to contracts.
+	MappedAccountType
+)
 
-type originRecoveryFunc func(tx SignedTx, allowedSigTypes []evmcompat.SignatureType) ([]byte, error)
+// Recovers the signer address from a signed tx.
+type originRecoveryFunc func(chainID string, tx SignedTx, allowedSigTypes []evmcompat.SignatureType) ([]byte, error)
 
 // NewMultiChainSignatureTxMiddleware returns tx signing middleware that supports a set of chain
 // specific signing algos.
@@ -76,12 +82,14 @@ func NewMultiChainSignatureTxMiddleware(
 			return r, fmt.Errorf("unknown chain ID %s", msgSender.ChainID)
 		}
 
-		recoverOrigin, found := originRecoveryFuncs[chain.TxType]
-		if !found {
+		recoverOrigin := getOriginRecoveryFunc(state, types.TxID(tx.Id), chain.TxType)
+		if recoverOrigin == nil {
 			return r, fmt.Errorf("recovery function for Tx type %v not found", chain.TxType)
 		}
 
-		recoveredAddr, err := recoverOrigin(signedTx, getAllowedSignatureTypes(state, msgSender.ChainID))
+		recoveredAddr, err := recoverOrigin(
+			state.Block().ChainID, signedTx, getAllowedSignatureTypes(state, msgSender.ChainID),
+		)
 		if err != nil {
 			return r, errors.Wrapf(err, "failed to recover origin (tx type %v, chain ID %s)",
 				chain.TxType, msgSender.ChainID,
@@ -132,6 +140,23 @@ func NewMultiChainSignatureTxMiddleware(
 	})
 }
 
+func getOriginRecoveryFunc(state appstate.State, txID types.TxID, txType keys.SignedTxType) originRecoveryFunc {
+	switch txType {
+	case keys.LoomSignedTxType:
+		return verifyEd25519
+	case keys.EthereumSignedTxType:
+		if (txID == types.TxID_ETHEREUM) && state.FeatureEnabled(features.EthTxFeature, false) {
+			return VerifyWrappedEthTx
+		}
+		return verifySolidity66Byte
+	case keys.TronSignedTxType:
+		return verifyTron
+	case keys.BinanceSignedTxType:
+		return verifyBinance
+	}
+	return nil
+}
+
 func getMappedAccountAddress(
 	state appstate.State,
 	addr loom.Address,
@@ -159,7 +184,7 @@ func getMappedAccountAddress(
 	return mappedAddr, nil
 }
 
-func verifyEd25519(tx SignedTx, _ []evmcompat.SignatureType) ([]byte, error) {
+func verifyEd25519(chainID string, tx SignedTx, _ []evmcompat.SignatureType) ([]byte, error) {
 	if len(tx.PublicKey) != ed25519.PublicKeySize {
 		return nil, errors.New("invalid public key length")
 	}

auth/multi_chain_sigtx_middleware_test.go

@@ -18,6 +18,7 @@ import (
 	"github.com/loomnetwork/go-loom/common/evmcompat"
 	goloomplugin "github.com/loomnetwork/go-loom/plugin"
 	"github.com/loomnetwork/go-loom/plugin/contractpb"
+	"github.com/loomnetwork/go-loom/types"
 	gltypes "github.com/loomnetwork/go-loom/types"
 	"github.com/loomnetwork/go-loom/vm"
 	sha3 "github.com/miguelmota/go-solidity-sha3"
@@ -34,8 +35,9 @@ import (
 )
 
 const (
+	sequence           = uint64(4)
 	callId             = uint32(2)
-	seq                = uint64(4)
+	seq                = uint64(4) // todo
 	defaultLoomChainId = "default"
 )
 
@@ -218,7 +220,7 @@ func TestEthAddressMappingVerification(t *testing.T) {
 	ethPublicAddr := loom.Address{ChainID: "eth", Local: ethLocalAdr}
 
 	// tx using address mapping from eth account. Gives error.
-	txSigned = mockSignedTx(t, "eth", &auth.EthSigner66Byte{ethKey})
+	txSigned = mockSignedTx(t, "eth", &auth.EthSigner66Byte{PrivateKey: ethKey})
 	_, err = throttleMiddlewareHandler(tmx, state, txSigned, ctx)
 	require.Error(t, err)
 
@@ -278,7 +280,6 @@ func TestBinanceAddressMappingVerification(t *testing.T) {
 	require.NoError(t, am.Init(amCtx, &address_mapper.InitRequest{}))
 
 	// generate eth key
-	// ethKey, err := crypto.GenerateKey()
 	privKey, err := crypto.HexToECDSA(ethPrivateKey)
 	require.NoError(t, err)
 	signer := auth.NewBinanceSigner(crypto.FromECDSA(privKey))
@@ -365,15 +366,15 @@ func TestChainIdVerification(t *testing.T) {
 	// to contracts will be eth:xxxxxx, i.e. the eth account is passed through without being mapped
 	// to a DAppChain account.
 	// Don't try this in production.
-	txSigned = mockSignedTx(t, "eth", &auth.EthSigner66Byte{ethKey})
+	txSigned = mockSignedTx(t, "eth", &auth.EthSigner66Byte{PrivateKey: ethKey})
 	_, err = throttleMiddlewareHandler(tmx, state, txSigned, ctx)
 	require.NoError(t, err)
 
 	// Tx signed with Ethereum key, address mapping disabled, the caller address passed through
 	// to contracts will be tron:xxxxxx, i.e. the eth account is passed through without being mapped
 	// to a DAppChain account.
 	// Don't try this in production.
-	txSigned = mockSignedTx(t, "tron", &auth.TronSigner{ethKey})
+	txSigned = mockSignedTx(t, "tron", &auth.TronSigner{PrivateKey: ethKey})
 	_, err = throttleMiddlewareHandler(tmx, state, txSigned, ctx)
 	require.NoError(t, err)
 
@@ -466,7 +467,7 @@ func mockNonceTx(t *testing.T, from loom.Address, sequence uint64) []byte {
 	})
 	require.NoError(t, err)
 	tx, err := proto.Marshal(&gltypes.Transaction{
-		Id:   callId,
+		Id:   uint32(types.TxID_CALL),
 		Data: messageTx,
 	})
 	require.Nil(t, err)

auth/noeth.go

@@ -8,14 +8,18 @@ import (
 	"github.com/loomnetwork/go-loom/common/evmcompat"
 )
 
-func verifySolidity66Byte(_ SignedTx, _ []evmcompat.SignatureType) ([]byte, error) {
+func verifySolidity66Byte(_ string, _ SignedTx, _ []evmcompat.SignatureType) ([]byte, error) {
 	return nil, fmt.Errorf("not implemented")
 }
 
-func verifyTron(_ SignedTx, _ []evmcompat.SignatureType) ([]byte, error) {
+func verifyTron(_ string, _ SignedTx, _ []evmcompat.SignatureType) ([]byte, error) {
 	return nil, fmt.Errorf("not implemented")
 }
 
-func verifyBinance(_ SignedTx, _ []evmcompat.SignatureType) ([]byte, error) {
+func verifyBinance(_ string, _ SignedTx, _ []evmcompat.SignatureType) ([]byte, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func VerifyWrappedEthTx(_ string, signedTx SignedTx, _ []evmcompat.SignatureType) ([]byte, error) {
 	return nil, fmt.Errorf("not implemented")
 }

cmd/loom/config.go

@@ -240,6 +240,10 @@ func defaultGenesis(cfg *config.Config, validator *loom.Validator) (*config.Gene
 					Name:   features.AuthSigTxFeaturePrefix + "eth",
 					Status: chainconfig.FeatureWaiting,
 				},
+				&cctypes.Feature{
+					Name:   features.EthTxFeature,
+					Status: chainconfig.FeatureWaiting,
+				},
 				&cctypes.Feature{
 					Name:   features.CheckTxValueFeature,
 					Status: chainconfig.FeatureWaiting,