Eth invoke expression tx

pkg/metamask/service.go

@@ -143,10 +143,6 @@ func (s RPCService) Eth_EstimateGas(req estimateGasRequest) (string, error) {
 		value = new(big.Int)
 		data  []byte
 	)
-	if req.To == nil {
-		zap.S().Debug("Eth_EstimateGas: trying estimate gas for set dApp transaction")
-		return "", errors.New("gas estimation for set dApp transaction is not permitted")
-	}
 	if req.Value != nil {
 		var _, ok = value.SetString(strings.TrimPrefix(*req.Value, "0x"), 16)
 		if !ok {
@@ -163,7 +159,7 @@ func (s RPCService) Eth_EstimateGas(req estimateGasRequest) (string, error) {
 		}
 	}
 
-	txKind, err := state.GuessEthereumTransactionKind(data)
+	txKind, err := state.GuessEthereumTransactionKind(data, req.To)
 	if err != nil {
 		return "", errors.Errorf("failed to guess ethereum tx kind, %v", err)
 	}

pkg/proto/eth_transaction.go

@@ -129,10 +129,13 @@ func (tx *EthereumTransferAssetsErc20TxKind) String() string {
 
 type EthereumInvokeScriptTxKind struct {
 	decodedData ethabi.DecodedCallData
+	TxID        *crypto.Digest
+	From        WavesAddress
+	To          WavesAddress
 }
 
-func NewEthereumInvokeScriptTxKind(decodedData ethabi.DecodedCallData) *EthereumInvokeScriptTxKind {
-	return &EthereumInvokeScriptTxKind{decodedData: decodedData}
+func NewEthereumInvokeScriptTxKind(decodedData ethabi.DecodedCallData, txID *crypto.Digest, from WavesAddress, to WavesAddress) *EthereumInvokeScriptTxKind {
+	return &EthereumInvokeScriptTxKind{decodedData: decodedData, TxID: txID, From: from, To: to}
 }
 
 func (tx *EthereumInvokeScriptTxKind) DecodedData() *ethabi.DecodedCallData {
@@ -143,6 +146,32 @@ func (tx *EthereumInvokeScriptTxKind) String() string {
 	return "EthereumInvokeScriptTxKind"
 }
 
+func (tx *EthereumInvokeScriptTxKind) markerInvokeScriptTx() {
+
+}
+
+type EthereumInvokeExpressionTxKind struct {
+	Expression string
+	TxID       *crypto.Digest
+	From       WavesAddress
+}
+
+func NewEthereumInvokeExpressionTxKind(expression string, txID *crypto.Digest, from WavesAddress) *EthereumInvokeExpressionTxKind {
+	return &EthereumInvokeExpressionTxKind{Expression: expression, TxID: txID, From: from}
+}
+
+func (tx *EthereumInvokeExpressionTxKind) DecodedData() *ethabi.DecodedCallData {
+	return nil
+}
+
+func (tx *EthereumInvokeExpressionTxKind) String() string {
+	return "EthereumInvokeExpressionTxKind"
+}
+
+func (tx *EthereumInvokeExpressionTxKind) markerInvokeExpressionTx() {
+
+}
+
 type EthereumTransaction struct {
 	inner           EthereumTxData
 	innerBinarySize int

pkg/proto/invoke_union.go

@@ -0,0 +1,41 @@
+package proto
+
+import "github.com/wavesplatform/gowaves/pkg/crypto"
+
+type InvokeTxUnion interface {
+	TxID() crypto.Digest
+}
+
+type InvokeScriptSubTransaction interface {
+	markerInvokeScriptTx()
+}
+
+type InvokeExpressionSubTransaction interface {
+	markerInvokeExpressionTx()
+}
+
+type InvokeScriptTxUnion struct {
+	SubTx InvokeScriptSubTransaction
+	txID  crypto.Digest
+}
+
+func NewInvokeScriptTxUnion(subTransaction InvokeScriptSubTransaction, id crypto.Digest) *InvokeScriptTxUnion {
+	return &InvokeScriptTxUnion{SubTx: subTransaction, txID: id}
+}
+
+func (invScript InvokeScriptTxUnion) TxID() crypto.Digest {
+	return invScript.txID
+}
+
+type InvokeExpressionTxUnion struct {
+	SubTx InvokeExpressionSubTransaction
+	txID  crypto.Digest
+}
+
+func NewInvokeExpressionTxUnion(subTransaction InvokeExpressionSubTransaction, id crypto.Digest) *InvokeExpressionTxUnion {
+	return &InvokeExpressionTxUnion{SubTx: subTransaction, txID: id}
+}
+
+func (invExp InvokeExpressionTxUnion) TxID() crypto.Digest {
+	return invExp.txID
+}

pkg/proto/transactions.go

@@ -39,7 +39,6 @@ const (
 	UpdateAssetInfoTransaction                             // 17 - UpdateAssetInfoTransaction
 	InvokeExpressionTransaction                            // 18 - InvokeExpressionTransaction
 	EthereumMetamaskTransaction                            // 19 - EthereumMetamaskTransaction is a transaction which is received from metamask
-
 )
 
 // TxFailureReason indicates Transactions failure reasons.

pkg/proto/transactions_with_proofs.go

@@ -4758,6 +4758,9 @@ func (tx *InvokeScriptWithProofs) ToProtobufSigned(scheme Scheme) (*g.SignedTran
 	}, nil
 }
 
+func (tx *InvokeScriptWithProofs) markerInvokeScriptTx() {
+}
+
 type UpdateAssetInfoWithProofs struct {
 	Type        TransactionType  `json:"type"`
 	Version     byte             `json:"version,omitempty"`
@@ -5136,3 +5139,7 @@ func (tx *InvokeExpressionTransactionWithProofs) ToProtobufSigned(scheme Scheme)
 		Proofs:      tx.Proofs.Bytes(),
 	}, nil
 }
+
+func (tx *InvokeExpressionTransactionWithProofs) markerInvokeExpressionTx() {
+
+}

pkg/ride/converters.go

@@ -886,7 +886,7 @@ func invokeScriptWithProofsToObject(scheme byte, tx *proto.InvokeScriptWithProof
 	return r, nil
 }
 
-// TODO think of reusing "InvokeScripTToObject" function. Also should we fill "payments" and "function name" fields"?
+// TODO think of reusing "InvokeScripTToObject" function.TestEthereumInvokeWithoutPaymentsAndArguments
 func invokeExpressionWithProofsToObject(scheme byte, tx *proto.InvokeExpressionTransactionWithProofs) (rideObject, error) {
 	sender, err := proto.NewAddressFromPublicKey(scheme, tx.SenderPK)
 	if err != nil {
@@ -982,13 +982,16 @@ func ethereumTransactionToObject(scheme proto.Scheme, tx *proto.EthereumTransact
 	r["bodyBytes"] = rideBytes(nil)
 	r["proofs"] = proofs(proto.NewProofs())
 
+	r["version"] = rideInt(tx.GetVersion())
+	r["id"] = rideBytes(tx.ID.Bytes())
+	r["sender"] = rideAddress(sender)
+	r["senderPublicKey"] = rideBytes(callerPK)
+	r["feeAssetId"] = optionalAsset(proto.NewOptionalAssetWaves())
+	r["timestamp"] = rideInt(tx.GetTimestamp())
+	r["fee"] = rideInt(tx.GetFee())
 	switch kind := tx.TxKind.(type) {
 	case *proto.EthereumTransferWavesTxKind:
 		r[instanceFieldName] = rideString("TransferTransaction")
-		r["version"] = rideInt(tx.GetVersion())
-		r["id"] = rideBytes(tx.ID.Bytes())
-		r["sender"] = rideAddress(sender)
-		r["senderPublicKey"] = rideBytes(callerPK)
 		r["recipient"] = rideRecipient(proto.NewRecipientFromAddress(*to))
 		r["assetId"] = optionalAsset(proto.NewOptionalAssetWaves())
 		res := new(big.Int).Div(tx.Value(), big.NewInt(int64(proto.DiffEthWaves)))
@@ -999,36 +1002,21 @@ func ethereumTransactionToObject(scheme proto.Scheme, tx *proto.EthereumTransact
 		}
 		amount := res.Int64()
 		r["amount"] = rideInt(amount)
-		r["fee"] = rideInt(tx.GetFee())
-		r["feeAssetId"] = optionalAsset(proto.NewOptionalAssetWaves())
 		r["attachment"] = rideBytes(nil)
-		r["timestamp"] = rideInt(tx.GetTimestamp())
 
 	case *proto.EthereumTransferAssetsErc20TxKind:
 		r[instanceFieldName] = rideString("TransferTransaction")
-		r["version"] = rideInt(tx.GetVersion())
-		r["id"] = rideBytes(tx.ID.Bytes())
-		r["sender"] = rideAddress(sender)
-		r["senderPublicKey"] = rideBytes(callerPK)
-
 		recipientAddr, err := proto.EthereumAddress(kind.Arguments.Recipient).ToWavesAddress(scheme)
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to convert ethereum ERC20 transfer recipient to WavesAddress")
 		}
 		r["recipient"] = rideRecipient(proto.NewRecipientFromAddress(recipientAddr))
 		r["assetId"] = optionalAsset(kind.Asset)
 		r["amount"] = rideInt(kind.Arguments.Amount)
-		r["fee"] = rideInt(tx.GetFee())
-		r["feeAssetId"] = optionalAsset(proto.NewOptionalAssetWaves())
 		r["attachment"] = rideBytes(nil)
-		r["timestamp"] = rideInt(tx.GetTimestamp())
 
 	case *proto.EthereumInvokeScriptTxKind:
 		r[instanceFieldName] = rideString("InvokeScriptTransaction")
-		r["version"] = rideInt(tx.GetVersion())
-		r["id"] = rideBytes(tx.ID.Bytes())
-		r["sender"] = rideAddress(sender)
-		r["senderPublicKey"] = rideBytes(callerPK)
 		r["dApp"] = rideRecipient(proto.NewRecipientFromAddress(*to))
 
 		var scriptPayments []proto.ScriptPayment
@@ -1059,7 +1047,6 @@ func ethereumTransactionToObject(scheme proto.Scheme, tx *proto.EthereumTransact
 			r["payment"] = rideUnit{}
 			r["payments"] = make(rideList, 0)
 		}
-		r["feeAssetId"] = optionalAsset(proto.NewOptionalAssetWaves())
 		r["function"] = rideString(tx.TxKind.DecodedData().Name)
 		arguments, err := ConvertDecodedEthereumArgumentsToProtoArguments(tx.TxKind.DecodedData().Inputs)
 		if err != nil {
@@ -1074,9 +1061,14 @@ func ethereumTransactionToObject(scheme proto.Scheme, tx *proto.EthereumTransact
 			args[i] = a
 		}
 		r["args"] = args
-		r["fee"] = rideInt(tx.GetFee())
-		r["timestamp"] = rideInt(tx.GetTimestamp())
-
+	case *proto.EthereumInvokeExpressionTxKind:
+		r := make(rideObject)
+		r[instanceFieldName] = rideString("InvokeExpressionTransaction")
+		r["dApp"] = rideRecipient(proto.NewRecipientFromAddress(sender))
+		r["payment"] = rideUnit{}
+		r["payments"] = make(rideList, 0)
+		r["function"] = rideString("default")
+		r["args"] = rideList{}
 	default:
 		return nil, errors.New("unknown ethereum transaction kind")
 	}
@@ -1189,6 +1181,7 @@ func invocationToObject(rideVersion int, scheme byte, tx proto.Transaction) (rid
 		ID = *transaction.ID
 		FeeAsset = transaction.FeeAsset
 		Fee = transaction.Fee
+
 		switch rideVersion {
 		case 1, 2, 3:
 			r["payment"] = rideUnit{}

pkg/ride/environment.go

@@ -1365,8 +1365,12 @@ func (e *EvaluationEnvironment) SetInvoke(tx proto.Transaction, v int) error {
 	return nil
 }
 
-func (e *EvaluationEnvironment) SetEthereumInvoke(tx *proto.EthereumTransaction, v int, payments []proto.ScriptPayment) error {
-	obj, err := ethereumInvocationToObject(v, e.sch, tx, payments)
+func (e *EvaluationEnvironment) SetEthereumInvoke(tx proto.Transaction, v int, payments []proto.ScriptPayment) error {
+	ethTx, ok := tx.(*proto.EthereumTransaction)
+	if !ok {
+		return errors.New("failed to transform interface to ethereum transaction")
+	}
+	obj, err := ethereumInvocationToObject(v, e.sch, ethTx, payments)
 	if err != nil {
 		return err
 	}

pkg/state/appender.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/mr-tron/base58/base58"
 	"github.com/pkg/errors"
-	"github.com/wavesplatform/gowaves/pkg/crypto"
 	"github.com/wavesplatform/gowaves/pkg/errs"
 	"github.com/wavesplatform/gowaves/pkg/proto"
 	"github.com/wavesplatform/gowaves/pkg/settings"
@@ -212,9 +211,9 @@ func (a *txAppender) checkTxFees(tx proto.Transaction, info *fallibleValidationP
 		if err != nil {
 			return err
 		}
-		// TODO handle ethereum invoke expression tx
+		// ethereum InvokeScript and InvokeExpression
 	case proto.EthereumMetamaskTransaction:
-		feeChanges, err = a.txHandler.td.createFeeDiffEthereumInvokeScriptWithProofs(tx, differInfo)
+		feeChanges, err = a.txHandler.td.createFeeDiffEthereumInvokeWithProofs(tx, differInfo)
 		if err != nil {
 			return err
 		}
@@ -497,9 +496,7 @@ func (a *txAppender) appendTx(tx proto.Transaction, params *appendTxParams) erro
 					ethTx.TxKind.String(), ethTx.ID.String(), params.checkerInfo.height+1, err,
 				)
 			}
-			// In UTX balances are always validated.
-			needToValidateBalanceDiff = params.validatingUtx
-		case *proto.EthereumInvokeScriptTxKind:
+		case *proto.EthereumInvokeScriptTxKind, *proto.EthereumInvokeExpressionTxKind:
 			fallibleInfo := &fallibleValidationParams{
 				appendTxParams: params,
 				senderScripted: accountHasVerifierScript,
@@ -512,7 +509,10 @@ func (a *txAppender) appendTx(tx proto.Transaction, params *appendTxParams) erro
 					ethTx.TxKind.String(), ethTx.ID.String(), params.checkerInfo.height+1, err,
 				)
 			}
+
 		}
+		// In UTX balances are always validated.
+		needToValidateBalanceDiff = params.validatingUtx
 	default:
 		applicationRes, err = a.handleDefaultTransaction(tx, params, accountHasVerifierScript)
 		if err != nil {
@@ -646,27 +646,28 @@ type applicationResult struct {
 }
 
 func (a *txAppender) handleInvoke(tx proto.Transaction, info *fallibleValidationParams) (*applicationResult, error) {
-	var ID crypto.Digest
+	var invokeUnion proto.InvokeTxUnion
 	switch t := tx.(type) {
 	case *proto.InvokeScriptWithProofs:
-		ID = *t.ID
+		invokeUnion = proto.NewInvokeScriptTxUnion(t, *t.ID)
 	case *proto.InvokeExpressionTransactionWithProofs:
-		ID = *t.ID
-	case *proto.EthereumTransaction:
-		// TODO: handle ethereum invoke expression tx
-		switch t.TxKind.(type) {
+		invokeUnion = proto.NewInvokeExpressionTxUnion(t, *t.ID)
+	case *proto.EthereumTransaction: // ethereum InvokeExpression and InvokeScript
+		switch kind := t.TxKind.(type) {
 		case *proto.EthereumInvokeScriptTxKind:
-			ID = *t.ID
+			invokeUnion = proto.NewInvokeScriptTxUnion(kind, *t.ID)
+		case *proto.EthereumInvokeExpressionTxKind:
+			invokeUnion = proto.NewInvokeExpressionTxUnion(kind, *t.ID)
 		default:
-			return nil, errors.Errorf("unexpected ethereum tx kind (%T)", tx)
+			return nil, errors.Errorf("failed to handle invoke: wrong type of ethereum transactiion (%T)", tx)
 		}
-		ID = *t.ID
 	default:
 		return nil, errors.Errorf("failed to handle invoke: wrong type of transaction (%T)", tx)
 	}
-	res, err := a.ia.applyInvokeScript(tx, info)
+
+	res, err := a.ia.applyInvokeScript(tx, invokeUnion, info)
 	if err != nil {
-		zap.S().Debugf("failed to apply InvokeScript transaction %s to state: %v", ID.String(), err)
+		zap.S().Debugf("failed to apply InvokeScript transaction %s to state: %v", invokeUnion.TxID().String(), err)
 		return nil, err
 	}
 	return res, nil

pkg/state/block_differ.go

@@ -125,7 +125,7 @@ func (d *blockDiffer) createFailedTransactionDiff(tx proto.Transaction, block *p
 			return txBalanceChanges{}, err
 		}
 	case proto.EthereumMetamaskTransaction:
-		txChanges, err = d.handler.td.createFeeDiffEthereumInvokeScriptWithProofs(tx, differInfo)
+		txChanges, err = d.handler.td.createFeeDiffEthereumInvokeWithProofs(tx, differInfo)
 		if err != nil {
 			return txBalanceChanges{}, err
 		}