Ethereum transaction refactoring

pkg/metamask/service.go

@@ -163,14 +163,14 @@ func (s RPCService) Eth_EstimateGas(req estimateGasRequest) (string, error) {
 		}
 	}
 
-	txKind, err := state.GuessEthereumTransactionKind(data)
+	txKind, err := proto.GuessEthereumTransactionKind(data)
 	if err != nil {
 		return "", errors.Errorf("failed to guess ethereum tx kind, %v", err)
 	}
 	switch txKind {
-	case state.EthereumTransferWavesKind:
+	case proto.EthereumTransferWavesKind:
 		return fmt.Sprintf("%d", proto.MinFee), nil
-	case state.EthereumTransferAssetsKind:
+	case proto.EthereumTransferAssetsKind:
 		fee := proto.MinFee
 		assetID := (*proto.AssetID)(req.To)
 
@@ -182,7 +182,7 @@ func (s RPCService) Eth_EstimateGas(req estimateGasRequest) (string, error) {
 			fee += proto.MinFeeScriptedAsset
 		}
 		return fmt.Sprintf("%d", fee), nil
-	case state.EthereumInvokeKind:
+	case proto.EthereumInvokeKind:
 		fee := proto.MinFeeInvokeScript
 
 		scriptAddr, err := req.To.ToWavesAddress(s.nodeRPCApp.Scheme)
@@ -201,7 +201,7 @@ func (s RPCService) Eth_EstimateGas(req estimateGasRequest) (string, error) {
 		if err != nil {
 			return "", err
 		}
-		decodedData, err := db.ParseCallDataRide(data)
+		decodedData, err := db.ParseCallData(data)
 		if err != nil {
 			return "", errors.Errorf("failed to parse ethereum data, %v", err)
 		}

pkg/proto/eth_access_list_tx_test.go

@@ -13,7 +13,7 @@ func TestEthereumAccessListTxCanonical(t *testing.T) {
 		require.NoError(t, err)
 		return data
 	}
-	const expectedCanonical = "0x01f8630103018261a894b94f5374fce5edbc8e2a8697c15331677e6ebf0b0a825544c001a0c9519f4f2b30335884581971573fadf60c6204f59a911df35ee8a540456b2660a032f1e8e2c5dd761f9e4f88f41c8310aeaba26a8bfcdacfedfa12ec3862d37521"
+	const expectedCanonical = "0x01f8650103018261a894b94f5374fce5edbc8e2a8697c15331677e6ebf0b0a84bdc01110c001a0c9519f4f2b30335884581971573fadf60c6204f59a911df35ee8a540456b2660a032f1e8e2c5dd761f9e4f88f41c8310aeaba26a8bfcdacfedfa12ec3862d37521"
 	var (
 		expectedCanonicalBytes = mustDecodeFomHexString(expectedCanonical)
 		testAddrBytes          = mustDecodeFomHexString("0xb94f5374fce5edbc8e2a8697c15331677e6ebf0b")
@@ -34,7 +34,7 @@ func TestEthereumAccessListTxCanonical(t *testing.T) {
 		Value:    big.NewInt(10),
 		Gas:      25000,
 		GasPrice: big.NewInt(1),
-		Data:     mustDecodeFomHexString("5544"),
+		Data:     mustDecodeFomHexString("0xbdc01110"),
 		V:        &v,
 		R:        &r,
 		S:        &s,

pkg/proto/eth_signer.go

@@ -180,7 +180,7 @@ func (s londonSigner) SenderPK(tx *EthereumTransaction) (*EthereumPublicKey, err
 	// DynamicFee txs are defined to use 0 and 1 as their recovery
 	// id, add 27 to become equivalent to unprotected Homestead signatures.
 	V = new(big.Int).Add(V, big.NewInt(27))
-	if tx.ChainId().Cmp(s.chainId) != 0 {
+	if tx.inner.chainID().Cmp(s.chainId) != 0 {
 		return nil, ErrInvalidChainId
 	}
 	return recoverEthereumPubKey(s.Hash(tx), R, S, V, true)
@@ -262,7 +262,7 @@ func (s eip2930Signer) SenderPK(tx *EthereumTransaction) (*EthereumPublicKey, er
 	// AL txs are defined to use 0 and 1 as their recovery
 	// id, add 27 to become equivalent to unprotected Homestead signatures.
 	V = new(big.Int).Add(V, big.NewInt(27))
-	if tx.ChainId().Cmp(s.chainId) != 0 {
+	if tx.inner.chainID().Cmp(s.chainId) != 0 {
 		return nil, ErrInvalidChainId
 	}
 	return recoverEthereumPubKey(s.Hash(tx), R, S, V, true)
@@ -342,7 +342,7 @@ func (s eip155Signer) SenderPK(tx *EthereumTransaction) (*EthereumPublicKey, err
 	if !tx.Protected() {
 		return HomesteadSigner{}.SenderPK(tx)
 	}
-	if tx.ChainId().Cmp(s.chainId) != 0 {
+	if tx.inner.chainID().Cmp(s.chainId) != 0 {
 		return nil, ErrInvalidChainId
 	}
 	V, R, S := tx.RawSignatureValues()

pkg/proto/eth_transaction.go

@@ -27,6 +27,12 @@ const (
 	EthereumDynamicFeeTxType
 )
 
+const (
+	EthereumTransferWavesKind = iota + 1
+	EthereumTransferAssetsKind
+	EthereumInvokeKind
+)
+
 const (
 	EthereumTransferMinFee      uint64 = 100_000
 	EthereumScriptedAssetMinFee uint64 = 400_000
@@ -91,7 +97,7 @@ type EthereumTxData interface {
 
 type EthereumTransactionKind interface {
 	String() string
-	DecodedData() *ethabi.DecodedCallData
+	DecodedData() (*ethabi.DecodedCallData, error)
 }
 
 type EthereumTransferWavesTxKind struct {
@@ -101,8 +107,8 @@ func NewEthereumTransferWavesTxKind() *EthereumTransferWavesTxKind {
 	return &EthereumTransferWavesTxKind{}
 }
 
-func (tx *EthereumTransferWavesTxKind) DecodedData() *ethabi.DecodedCallData {
-	return nil
+func (tx *EthereumTransferWavesTxKind) DecodedData() (*ethabi.DecodedCallData, error) {
+	return nil, errors.New("transfer waves ethereum tx kind does not have decoded call data")
 }
 
 func (tx *EthereumTransferWavesTxKind) String() string {
@@ -112,42 +118,57 @@ func (tx *EthereumTransferWavesTxKind) String() string {
 type EthereumTransferAssetsErc20TxKind struct {
 	decodedData ethabi.DecodedCallData
 	Arguments   ethabi.ERC20TransferArguments
-	Asset       OptionalAsset
+	OptAsset    *OptionalAsset
 }
 
-func NewEthereumTransferAssetsErc20TxKind(decodedData ethabi.DecodedCallData, asset OptionalAsset, arguments ethabi.ERC20TransferArguments) *EthereumTransferAssetsErc20TxKind {
-	return &EthereumTransferAssetsErc20TxKind{Asset: asset, decodedData: decodedData, Arguments: arguments}
+func NewEthereumTransferAssetsErc20TxKind(decodedData ethabi.DecodedCallData, asset *OptionalAsset, arguments ethabi.ERC20TransferArguments) *EthereumTransferAssetsErc20TxKind {
+	return &EthereumTransferAssetsErc20TxKind{OptAsset: asset, decodedData: decodedData, Arguments: arguments}
 }
 
-func (tx *EthereumTransferAssetsErc20TxKind) DecodedData() *ethabi.DecodedCallData {
-	return &tx.decodedData
+func (tx *EthereumTransferAssetsErc20TxKind) DecodedData() (*ethabi.DecodedCallData, error) {
+	return &tx.decodedData, nil
+}
+func (tx *EthereumTransferAssetsErc20TxKind) Asset() (*OptionalAsset, error) {
+	if tx.OptAsset == nil {
+		return nil, errors.New("asset field of ethereum transfer assets tx is empty")
+	}
+	return tx.OptAsset, nil
 }
 
 func (tx *EthereumTransferAssetsErc20TxKind) String() string {
 	return "EthereumTransferAssetsErc20TxKind"
 }
 
 type EthereumInvokeScriptTxKind struct {
-	decodedData ethabi.DecodedCallData
+	DecodedCallData *ethabi.DecodedCallData
 }
 
-func NewEthereumInvokeScriptTxKind(decodedData ethabi.DecodedCallData) *EthereumInvokeScriptTxKind {
-	return &EthereumInvokeScriptTxKind{decodedData: decodedData}
+func NewEthereumInvokeScriptTxKind(decodedData *ethabi.DecodedCallData) *EthereumInvokeScriptTxKind {
+	return &EthereumInvokeScriptTxKind{DecodedCallData: decodedData}
 }
 
-func (tx *EthereumInvokeScriptTxKind) DecodedData() *ethabi.DecodedCallData {
-	return &tx.decodedData
+func (tx *EthereumInvokeScriptTxKind) DecodedData() (*ethabi.DecodedCallData, error) {
+	if tx.DecodedCallData == nil {
+		return nil, errors.New("ethereum invoke script tx has empty decoded data")
+	}
+	return tx.DecodedCallData, nil
 }
 
 func (tx *EthereumInvokeScriptTxKind) String() string {
 	return "EthereumInvokeScriptTxKind"
 }
 
 type EthereumTransaction struct {
-	inner           EthereumTxData
-	innerBinarySize int
-	senderPK        atomic.Value // *EthereumPublicKey
+	// Ethereum representation
+	senderPK atomic.Value   // *EthereumPublicKey
+	inner    EthereumTxData //
+
+	// Waves representation
 	TxKind          EthereumTransactionKind
+	value           int64
+	chainID         int64
+	gasPrice        uint64
+	innerBinarySize int
 	ID              *crypto.Digest
 }
 
@@ -159,6 +180,9 @@ func NewEthereumTransaction(inner EthereumTxData, txKind EthereumTransactionKind
 		TxKind:          txKind,
 		ID:              id,
 	}
+	res := new(big.Int).Div(tx.inner.value(), big.NewInt(int64(DiffEthWaves)))
+	tx.value = res.Int64()
+
 	tx.threadSafeSetSenderPK(senderPK)
 	return tx
 }
@@ -215,7 +239,7 @@ func (tx *EthereumTransaction) Verify() (*EthereumPublicKey, error) {
 	if senderPK := tx.threadSafeGetSenderPK(); senderPK != nil {
 		return senderPK, nil
 	}
-	signer := MakeEthereumSigner(tx.ChainId())
+	signer := MakeEthereumSigner(tx.inner.chainID())
 	senderPK, err := signer.SenderPK(tx)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to verify EthereumTransaction")
@@ -228,9 +252,9 @@ func (tx *EthereumTransaction) Verify() (*EthereumPublicKey, error) {
 // This method doesn't include signature verification. Use Verify method for signature verification
 func (tx *EthereumTransaction) Validate(scheme Scheme) (Transaction, error) {
 	// same chainID
-	if tx.ChainId().Cmp(big.NewInt(int64(scheme))) != 0 {
+	if tx.ChainId() != int64(scheme) {
 		// TODO: introduce new error type for scheme validation
-		txChainID := tx.ChainId().Uint64()
+		txChainID := tx.ChainId()
 		return nil, errs.NewTxValidationError(fmt.Sprintf(
 			"Address belongs to another network: expected: %d(%c), actual: %d(%c)",
 			scheme, scheme,
@@ -250,6 +274,7 @@ func (tx *EthereumTransaction) Validate(scheme Scheme) (Transaction, error) {
 		return nil, errs.NewFeeValidation("insufficient fee")
 	}
 	// too many waves (this check doesn't exist in scala)
+	// TODO I'm not sure this is should be checked for all eth tx kinds. Only for transfer waves kind
 	wavelets, err := EthereumWeiToWavelet(tx.Value())
 	if err != nil {
 		return nil, errs.NewFeeValidation(err.Error())
@@ -259,15 +284,15 @@ func (tx *EthereumTransaction) Validate(scheme Scheme) (Transaction, error) {
 		return nil, errs.NewNonPositiveAmount(wavelets, "waves")
 	}
 	// a cancel transaction: value == 0 && data == 0x
-	if tx.Value().Cmp(big0) == 0 && len(tx.Data()) == 0 {
+	if tx.Value() == 0 && len(tx.Data()) == 0 {
 		return nil, errs.NewTxValidationError("Transaction cancellation is not supported")
 	}
 	// either data or value field is set
-	if tx.Value().Cmp(big0) != 0 && len(tx.Data()) != 0 {
+	if tx.Value() != 0 && len(tx.Data()) != 0 {
 		return nil, errs.NewTxValidationError("Transaction should have either data or value")
 	}
 	// gasPrice == 10GWei
-	if tx.GasPrice().Cmp(new(big.Int).SetUint64(EthereumGasPrice)) != 0 {
+	if tx.GasPrice() != EthereumGasPrice {
 		return nil, errs.NewTxValidationError("Gas price must be 10 Gwei")
 	}
 	// deny a contract creation transaction (this check doesn't exist in scala)
@@ -375,8 +400,8 @@ func (tx *EthereumTransaction) EthereumTxType() EthereumTxType {
 // ChainId returns the EIP155 chain ID of the transaction. The return value will always be
 // non-nil. For legacy transactions which are not replay-protected, the return value is
 // zero.
-func (tx *EthereumTransaction) ChainId() *big.Int {
-	return tx.inner.chainID()
+func (tx *EthereumTransaction) ChainId() int64 {
+	return tx.chainID
 }
 
 // Data returns the input data of the transaction.
@@ -389,16 +414,10 @@ func (tx *EthereumTransaction) AccessList() EthereumAccessList { return tx.inner
 func (tx *EthereumTransaction) Gas() uint64 { return tx.inner.gas() }
 
 // GasPrice returns the gas price of the transaction.
-func (tx *EthereumTransaction) GasPrice() *big.Int { return copyBigInt(tx.inner.gasPrice()) }
-
-// GasTipCap returns the gasTipCap per gas of the transaction.
-func (tx *EthereumTransaction) GasTipCap() *big.Int { return copyBigInt(tx.inner.gasTipCap()) }
-
-// GasFeeCap returns the fee cap per gas of the transaction.
-func (tx *EthereumTransaction) GasFeeCap() *big.Int { return copyBigInt(tx.inner.gasFeeCap()) }
+func (tx *EthereumTransaction) GasPrice() uint64 { return tx.gasPrice }
 
 // Value returns the ether amount of the transaction.
-func (tx *EthereumTransaction) Value() *big.Int { return copyBigInt(tx.inner.value()) }
+func (tx *EthereumTransaction) Value() int64 { return tx.value }
 
 // Nonce returns the sender account nonce of the transaction.
 func (tx *EthereumTransaction) Nonce() uint64 { return tx.inner.nonce() }
@@ -458,6 +477,98 @@ func (tx *EthereumTransaction) RawSignatureValues() (v, r, s *big.Int) {
 	return tx.inner.rawSignatureValues()
 }
 
+func validateEthereumTx(tx *EthereumTransaction) error {
+	switch tx.TxKind.(type) {
+	case *EthereumTransferWavesTxKind:
+		res := new(big.Int).Div(tx.inner.value(), big.NewInt(int64(DiffEthWaves)))
+		if ok := res.IsInt64(); !ok {
+			return errors.Errorf("failed to convert amount from ethreum transaction (big int) to int64. value is %d", tx.Value())
+		}
+		tx.value = res.Int64()
+		return nil
+	case *EthereumTransferAssetsErc20TxKind:
+		return nil
+	case *EthereumInvokeScriptTxKind:
+		return nil
+	default:
+		return errors.New("failed to check ethereum transaction, wrong kind of tx")
+	}
+}
+
+func GuessEthereumTransactionKind(data []byte) (int64, error) {
+	if len(data) == 0 {
+		return EthereumTransferWavesKind, nil
+	}
+
+	selectorBytes := data
+	if len(data) < ethabi.SelectorSize {
+		return 0, errors.Errorf("length of data from ethereum transaction is less than %d", ethabi.SelectorSize)
+	}
+	selector, err := ethabi.NewSelectorFromBytes(selectorBytes[:ethabi.SelectorSize])
+	if err != nil {
+		return 0, errors.Wrap(err, "failed to guess ethereum transaction kind")
+	}
+
+	if ethabi.IsERC20TransferSelector(selector) {
+		return EthereumTransferAssetsKind, nil
+	}
+
+	return EthereumInvokeKind, nil
+}
+
+// note: in this method not all of the fields are filled
+func GetEthereumTransactionKind(ethTx EthereumTransaction) (EthereumTransactionKind, error) {
+	txKind, err := GuessEthereumTransactionKind(ethTx.Data())
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to guess ethereum tx kind")
+	}
+
+	switch txKind {
+	case EthereumTransferWavesKind:
+		return NewEthereumTransferWavesTxKind(), nil
+	case EthereumTransferAssetsKind:
+		db := ethabi.NewErc20MethodsMap()
+		decodedData, err := db.ParseCallData(ethTx.Data())
+		if err != nil {
+			return nil, errors.Errorf("failed to parse ethereum data")
+		}
+		if len(decodedData.Inputs) != ethabi.NumberOfERC20TransferArguments {
+			return nil, errors.Errorf("the number of arguments of erc20 function is %d, but expected it to be %d", len(decodedData.Inputs), ethabi.NumberOfERC20TransferArguments)
+		}
+
+		erc20Arguments, err := ethabi.GetERC20TransferArguments(decodedData)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to get erc20 arguments from decoded data")
+		}
+		return NewEthereumTransferAssetsErc20TxKind(*decodedData, nil, erc20Arguments), nil
+	case EthereumInvokeKind:
+		return NewEthereumInvokeScriptTxKind(nil), nil
+	default:
+		return nil, errors.New("unexpected ethereum tx kind")
+	}
+}
+
+func (tx *EthereumTransaction) initTransactionFields() error {
+	if ok := tx.inner.chainID().IsInt64(); !ok {
+		return errors.Errorf("failed to recognize chainID of ethereum transaction: over int64")
+	}
+	tx.chainID = tx.inner.chainID().Int64()
+	if ok := tx.inner.gasPrice().IsUint64(); !ok {
+		return errors.Errorf("failed to recognize GasPrice of ethereum transaction: over uint64")
+	}
+	tx.gasPrice = tx.inner.gasPrice().Uint64()
+	var err error
+	tx.TxKind, err = GetEthereumTransactionKind(*tx)
+	if err != nil {
+		return errors.Errorf("failed to guess ethereum transaction kind, %v", err)
+	}
+	err = validateEthereumTx(tx)
+	if err != nil {
+		return errors.Errorf("validation of ethereum transaction after initialization failed , %v", err)
+	}
+	return nil
+}
+
 // DecodeCanonical decodes the canonical binary encoding of transactions.
 // It supports legacy RLP transactions and EIP2718 typed transactions.
 func (tx *EthereumTransaction) DecodeCanonical(canonicalData []byte) error {
@@ -488,6 +599,11 @@ func (tx *EthereumTransaction) DecodeCanonical(canonicalData []byte) error {
 		tx.inner = inner
 	}
 	tx.innerBinarySize = len(canonicalData)
+
+	err := tx.initTransactionFields()
+	if err != nil {
+		return errors.Wrap(err, "failed to initialize waves representation fields of ethereum transaction")
+	}
 	return nil
 }