[KLC-1601] Fix relayer transaction creation

clients/klever/client.go

@@ -9,6 +9,8 @@ import (
 	"sync"
 	"time"
 
+	factoryHasher "github.com/klever-io/klever-go/crypto/hashing/factory"
+	"github.com/klever-io/klever-go/tools/marshal/factory"
 	"github.com/klever-io/klv-bridge-eth-go/clients"
 	"github.com/klever-io/klv-bridge-eth-go/clients/klever/blockchain/address"
 	"github.com/klever-io/klv-bridge-eth-go/clients/klever/blockchain/builders"
@@ -24,13 +26,13 @@ import (
 )
 
 const (
-	proposeTransferFuncName         = "proposeMultiTransferEsdtBatch"
-	proposeSetStatusFuncName        = "proposeEsdtSafeSetCurrentTransactionBatchStatus"
+	proposeTransferFuncName         = "proposeMultiTransferKdaBatch"
+	proposeSetStatusFuncName        = "proposeKdaSafeSetCurrentTransactionBatchStatus"
 	signFuncName                    = "sign"
 	performActionFuncName           = "performAction"
 	minClientAvailabilityAllowDelta = 1
 
-	multiversXDataGetterLogId = "MultiversXEth-MultiversXDataGetter"
+	kleverDataGetterLogId = "KleverEth-KleverDataGetter"
 )
 
 // ClientArgs represents the argument for the NewClient constructor function
@@ -48,7 +50,7 @@ type ClientArgs struct {
 	ClientAvailabilityAllowDelta uint64
 }
 
-// client represents the MultiversX Client implementation
+// client represents the Klever Blockchain Client implementation
 type client struct {
 	*klvClientDataGetter
 	txHandler                    txHandler
@@ -68,7 +70,7 @@ type client struct {
 	mut                      sync.RWMutex
 }
 
-// NewClient returns a new MultiversX Client instance
+// NewClient returns a new Klever Blockchain Client instance
 func NewClient(args ClientArgs) (*client, error) {
 	err := checkArgs(args)
 	if err != nil {
@@ -100,7 +102,7 @@ func NewClient(args ClientArgs) (*client, error) {
 		SafeContractAddress:     args.SafeContractAddress,
 		RelayerAddress:          relayerAddress,
 		Proxy:                   args.Proxy,
-		Log:                     bridgeCore.NewLoggerWithIdentifier(logger.GetOrCreate(multiversXDataGetterLogId), multiversXDataGetterLogId),
+		Log:                     bridgeCore.NewLoggerWithIdentifier(logger.GetOrCreate(kleverDataGetterLogId), kleverDataGetterLogId),
 	}
 	getter, err := NewKLVClientDataGetter(argsKLVClientDataGetter)
 	if err != nil {
@@ -116,6 +118,16 @@ func NewClient(args ClientArgs) (*client, error) {
 
 	bech23SafeAddress := args.SafeContractAddress.Bech32()
 
+	internalMarshalizer, err := factory.NewMarshalizer(factory.ProtoMarshalizer)
+	if err != nil {
+		return nil, err
+	}
+
+	hasher, err := factoryHasher.NewHasher("blake2b")
+	if err != nil {
+		return nil, err
+	}
+
 	c := &client{
 		txHandler: &transactionHandler{
 			proxy:                   args.Proxy,
@@ -125,6 +137,8 @@ func NewClient(args ClientArgs) (*client, error) {
 			relayerPrivateKey:       args.RelayerPrivateKey,
 			singleSigner:            &singlesig.Ed25519Signer{},
 			roleProvider:            args.RoleProvider,
+			internalMarshalizer:     internalMarshalizer,
+			hasher:                  hasher,
 		},
 		klvClientDataGetter:          getter,
 		relayerPublicKey:             publicKey,
@@ -140,7 +154,7 @@ func NewClient(args ClientArgs) (*client, error) {
 	}
 
 	bech32RelayerAddress := relayerAddress.Bech32()
-	c.log.Info("NewMultiversXClient",
+	c.log.Info("NewKleverBlockchainClient",
 		"relayer address", bech32RelayerAddress,
 		"multisig contract address", bech23MultisigAddress,
 		"safe contract address", bech23SafeAddress)

clients/klever/proxy/models/transactions.go

@@ -32,7 +32,7 @@ type SendTransactionResponse struct {
 
 // EstimateTransactionFeesResponse defines the structure of responses on EstimateTransactionFees API endpoint
 type EstimateTransactionFeesResponse struct {
-	Data  *transaction.FeesResponse `json:"fees"`
+	Data  *transaction.FeesResponse `json:"data"`
 	Error string                    `json:"error"`
 	Code  string                    `json:"code"`
 }

clients/klever/transactionHandler.go

@@ -2,9 +2,11 @@ package klever
 
 import (
 	"context"
-	"encoding/json"
 
+	"github.com/klever-io/klever-go/crypto/hashing"
 	"github.com/klever-io/klever-go/data/transaction"
+	"github.com/klever-io/klever-go/tools"
+	"github.com/klever-io/klever-go/tools/marshal"
 	"github.com/klever-io/klv-bridge-eth-go/clients/klever/blockchain/address"
 	"github.com/klever-io/klv-bridge-eth-go/clients/klever/blockchain/builders"
 	"github.com/klever-io/klv-bridge-eth-go/clients/klever/proxy"
@@ -19,6 +21,8 @@ type transactionHandler struct {
 	relayerPrivateKey       crypto.PrivateKey
 	singleSigner            crypto.SingleSigner
 	roleProvider            roleProvider
+	internalMarshalizer     marshal.Marshalizer
+	hasher                  hashing.Hasher
 }
 
 // SendTransactionReturnHash will try to assemble a transaction, sign it, send it and, if everything is OK, returns the transaction's hash
@@ -42,17 +46,29 @@ func (txHandler *transactionHandler) signTransaction(ctx context.Context, builde
 		return nil, err
 	}
 
-	dataBytes, err := builder.ToDataBytes()
+	scCallData, err := builder.ToDataBytes()
 	if err != nil {
 		return nil, err
 	}
 
 	senderByteAddress := txHandler.relayerAddress.Bytes()
 
 	// building transaction to be signed, and send using proxy interface, but noncehandler as intermediare to help with nonce logic
-	tx := transaction.NewBaseTransaction(senderByteAddress, 0, [][]byte{dataBytes}, 0, 0)
+	tx := transaction.NewBaseTransaction(senderByteAddress, 0, [][]byte{scCallData}, 0, 0)
 	tx.SetChainID([]byte(networkConfig.ChainID))
 
+	addr, err := address.NewAddress(txHandler.multisigAddressAsBech32)
+	if err != nil {
+		return nil, err
+	}
+
+	contractRequest := &transaction.SmartContract{
+		Type:    transaction.SmartContract_SCInvoke,
+		Address: addr.Bytes(),
+	}
+
+	tx.PushContract(transaction.TXContract_SmartContractType, contractRequest)
+
 	// uses addressNonceHandler to fetch gas price using proxy endpoint GetNetworkConfig, in case of klever should
 	// use node simulate transaction probably
 	err = txHandler.nonceTxHandler.ApplyNonceAndGasPrice(context.Background(), txHandler.relayerAddress, tx)
@@ -70,12 +86,12 @@ func (txHandler *transactionHandler) signTransaction(ctx context.Context, builde
 
 // signTransactionWithPrivateKey signs a transaction with the client's private key
 func (txHandler *transactionHandler) signTransactionWithPrivateKey(tx *transaction.Transaction) error {
-	bytes, err := json.Marshal(&tx)
+	hash, err := txHandler.computeTxHash(tx)
 	if err != nil {
 		return err
 	}
 
-	signature, err := txHandler.singleSigner.Sign(txHandler.relayerPrivateKey, bytes)
+	signature, err := txHandler.singleSigner.Sign(txHandler.relayerPrivateKey, hash)
 	if err != nil {
 		return err
 	}
@@ -85,6 +101,15 @@ func (txHandler *transactionHandler) signTransactionWithPrivateKey(tx *transacti
 	return nil
 }
 
+func (txHandler *transactionHandler) computeTxHash(tx *transaction.Transaction) ([]byte, error) {
+	hash, err := tools.CalculateHash(txHandler.internalMarshalizer, txHandler.hasher, tx.GetRawData())
+	if err != nil {
+		return nil, err
+	}
+
+	return hash, nil
+}
+
 // Close will close any sub-components it uses
 func (txHandler *transactionHandler) Close() error {
 	return txHandler.nonceTxHandler.Close()

clients/klever/transactionHandler_test.go

@@ -7,7 +7,9 @@ import (
 	"errors"
 	"testing"
 
+	factoryHasher "github.com/klever-io/klever-go/crypto/hashing/factory"
 	"github.com/klever-io/klever-go/data/transaction"
+	"github.com/klever-io/klever-go/tools/marshal/factory"
 	"github.com/klever-io/klv-bridge-eth-go/clients/klever/blockchain/address"
 	"github.com/klever-io/klv-bridge-eth-go/clients/klever/blockchain/builders"
 	"github.com/klever-io/klv-bridge-eth-go/clients/klever/proxy/models"
@@ -34,6 +36,9 @@ func createTransactionHandlerWithMockComponents() *transactionHandler {
 	pkBytes, _ := pk.ToByteArray()
 	relayerAddress, _ := address.NewAddressFromBytes(pkBytes)
 
+	internalMarshalizer, _ := factory.NewInternalMarshalizer()
+	hasher, _ := factoryHasher.NewHasher("blake2b")
+
 	return &transactionHandler{
 		proxy:                   &interactors.ProxyStub{},
 		relayerAddress:          relayerAddress,
@@ -42,6 +47,8 @@ func createTransactionHandlerWithMockComponents() *transactionHandler {
 		relayerPrivateKey:       sk,
 		singleSigner:            testSigner,
 		roleProvider:            &roleproviders.KleverRoleProviderStub{},
+		internalMarshalizer:     internalMarshalizer,
+		hasher:                  hasher,
 	}
 }
 
@@ -160,14 +167,14 @@ func TestTransactionHandler_SendTransactionReturnHash(t *testing.T) {
 
 				scAddr, err := address.NewAddressFromBytes(sc.Address)
 				require.Nil(t, err)
-				assert.Equal(t, testMultisigAddress, scAddr)
+				assert.Equal(t, testMultisigAddress, scAddr.Bech32())
 
 				assert.Equal(t, nonce, tx.GetNonce())
 				require.Len(t, tx.GetData(), 1)
 				assert.Equal(t, "function@62756666@16", string(tx.GetData()[0]))
 
 				require.Len(t, tx.GetSignature(), 1)
-				assert.Equal(t, "4d1578a5ea204fa65b209b62a508add5a003de6c8cae2908fceadb810e137ebc74fcdce534cccd05502df697d41276faf3e7decf4896dd378d88b223eef53107", hex.EncodeToString(tx.Signature[0]))
+				assert.Equal(t, "79d92742619102c9f158d73f4f41f4df60d2e51936fa763832a51e716c35b0800bf702bf5545b6b1f1b0dd9eb04d8069ed63d5509983654a1bb009437a70a40e", hex.EncodeToString(tx.Signature[0]))
 				assert.Equal(t, chainID, string(tx.GetRawData().GetChainID()))
 
 				return txHash, nil