Merge pull request #6384 from multiversx/merge-rc-1.7.next1-to-rc-1.8.0

Merge rc 1.7.next1 into rc 1.8.0

.github/workflows/build_and_test.yml

@@ -9,7 +9,7 @@ jobs:
   build:
     strategy:
       matrix:
-        runs-on: [ubuntu-latest, macos-13-xlarge]
+        runs-on: [ubuntu-latest, macos-13, macos-13-xlarge]
     runs-on: ${{ matrix.runs-on }}
     name: Build
     steps:

.github/workflows/create_release.yml

@@ -15,7 +15,7 @@ jobs:
   build:
     strategy:
       matrix:
-        runs-on: [ubuntu-latest, macos-13-xlarge]
+        runs-on: [ubuntu-latest, macos-13, macos-13-xlarge]
     runs-on: ${{ matrix.runs-on }}
     name: Build
     steps:

.github/workflows/docker-keygenerator.yaml

@@ -0,0 +1,36 @@
+name: Build & push keygenerator docker image
+
+on:
+  workflow_dispatch:
+  pull_request:
+
+jobs:
+  build-docker-image:
+    strategy:
+      matrix:
+        runs-on: [ubuntu-latest]
+    runs-on: ${{ matrix.runs-on }}
+
+    steps:
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log into Docker Hub
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push image to Docker Hub
+        id: push
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./docker/keygenerator/Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: multiversx/chain-keygenerator:latest

api/errors/errors.go

@@ -174,3 +174,6 @@ var ErrGetWaitingManagedKeys = errors.New("error getting the waiting managed key
 
 // ErrGetWaitingEpochsLeftForPublicKey signals that an error occurred while getting the waiting epochs left for public key
 var ErrGetWaitingEpochsLeftForPublicKey = errors.New("error getting the waiting epochs left for public key")
+
+// ErrRecursiveRelayedTxIsNotAllowed signals that recursive relayed tx is not allowed
+var ErrRecursiveRelayedTxIsNotAllowed = errors.New("recursive relayed tx is not allowed")

api/groups/addressGroup.go

@@ -72,9 +72,11 @@ type esdtTokenData struct {
 	Properties      string `json:"properties"`
 }
 
-type esdtNFTTokenData struct {
+// ESDTNFTTokenData defines the exposed nft token data structure
+type ESDTNFTTokenData struct {
 	TokenIdentifier string   `json:"tokenIdentifier"`
 	Balance         string   `json:"balance"`
+	Type            string   `json:"type"`
 	Properties      string   `json:"properties,omitempty"`
 	Name            string   `json:"name,omitempty"`
 	Nonce           uint64   `json:"nonce,omitempty"`
@@ -448,7 +450,7 @@ func (ag *addressGroup) getAllESDTData(c *gin.Context) {
 		return
 	}
 
-	formattedTokens := make(map[string]*esdtNFTTokenData)
+	formattedTokens := make(map[string]*ESDTNFTTokenData)
 	for tokenID, esdtData := range tokens {
 		tokenData := buildTokenDataApiResponse(tokenID, esdtData)
 
@@ -481,12 +483,14 @@ func (ag *addressGroup) isDataTrieMigrated(c *gin.Context) {
 	shared.RespondWithSuccess(c, gin.H{"isMigrated": isMigrated})
 }
 
-func buildTokenDataApiResponse(tokenIdentifier string, esdtData *esdt.ESDigitalToken) *esdtNFTTokenData {
-	tokenData := &esdtNFTTokenData{
+func buildTokenDataApiResponse(tokenIdentifier string, esdtData *esdt.ESDigitalToken) *ESDTNFTTokenData {
+	tokenData := &ESDTNFTTokenData{
 		TokenIdentifier: tokenIdentifier,
 		Balance:         esdtData.Value.String(),
 		Properties:      hex.EncodeToString(esdtData.Properties),
 	}
+
+	tokenType := core.ESDTType(esdtData.Type).String()
 	if esdtData.TokenMetaData != nil {
 		tokenData.Name = string(esdtData.TokenMetaData.Name)
 		tokenData.Nonce = esdtData.TokenMetaData.Nonce
@@ -495,11 +499,25 @@ func buildTokenDataApiResponse(tokenIdentifier string, esdtData *esdt.ESDigitalT
 		tokenData.Hash = esdtData.TokenMetaData.Hash
 		tokenData.URIs = esdtData.TokenMetaData.URIs
 		tokenData.Attributes = esdtData.TokenMetaData.Attributes
+
+		tokenType = getTokenType(esdtData.GetType(), tokenData.Nonce)
 	}
 
+	tokenData.Type = tokenType
+
 	return tokenData
 }
 
+func getTokenType(tokenType uint32, tokenNonce uint64) string {
+	isNotFungible := tokenNonce != 0
+	tokenTypeNotSet := isNotFungible && core.ESDTType(tokenType) == core.NonFungible
+	if tokenTypeNotSet {
+		return ""
+	}
+
+	return core.ESDTType(tokenType).String()
+}
+
 func (ag *addressGroup) getFacade() addressFacadeHandler {
 	ag.mutFacade.RLock()
 	defer ag.mutFacade.RUnlock()

api/groups/transactionGroup.go

@@ -182,27 +182,23 @@ func (tg *transactionGroup) simulateTransaction(c *gin.Context) {
 		return
 	}
 
-	txArgs := &external.ArgsCreateTransaction{
-		Nonce:            ftx.Nonce,
-		Value:            ftx.Value,
-		Receiver:         ftx.Receiver,
-		ReceiverUsername: ftx.ReceiverUsername,
-		Sender:           ftx.Sender,
-		SenderUsername:   ftx.SenderUsername,
-		GasPrice:         ftx.GasPrice,
-		GasLimit:         ftx.GasLimit,
-		DataField:        ftx.Data,
-		SignatureHex:     ftx.Signature,
-		ChainID:          ftx.ChainID,
-		Version:          ftx.Version,
-		Options:          ftx.Options,
-		Guardian:         ftx.GuardianAddr,
-		GuardianSigHex:   ftx.GuardianSignature,
+	innerTxs, err := tg.extractInnerTransactions(ftx.InnerTransactions)
+	if err != nil {
+		c.JSON(
+			http.StatusBadRequest,
+			shared.GenericAPIResponse{
+				Data:  nil,
+				Error: fmt.Sprintf("%s: %s", errors.ErrTxGenerationFailed.Error(), err.Error()),
+				Code:  shared.ReturnCodeRequestError,
+			},
+		)
+		return
 	}
-	start := time.Now()
-	tx, txHash, err := tg.getFacade().CreateTransaction(txArgs)
-	logging.LogAPIActionDurationIfNeeded(start, "API call: CreateTransaction")
 
+	if len(innerTxs) == 0 {
+		innerTxs = nil
+	}
+	tx, txHash, err := tg.createTransaction(&ftx, innerTxs)
 	if err != nil {
 		c.JSON(
 			http.StatusBadRequest,
@@ -215,7 +211,7 @@ func (tg *transactionGroup) simulateTransaction(c *gin.Context) {
 		return
 	}
 
-	start = time.Now()
+	start := time.Now()
 	err = tg.getFacade().ValidateTransactionForSimulation(tx, checkSignature)
 	logging.LogAPIActionDurationIfNeeded(start, "API call: ValidateTransactionForSimulation")
 	if err != nil {
@@ -272,26 +268,23 @@ func (tg *transactionGroup) sendTransaction(c *gin.Context) {
 		return
 	}
 
-	txArgs := &external.ArgsCreateTransaction{
-		Nonce:            ftx.Nonce,
-		Value:            ftx.Value,
-		Receiver:         ftx.Receiver,
-		ReceiverUsername: ftx.ReceiverUsername,
-		Sender:           ftx.Sender,
-		SenderUsername:   ftx.SenderUsername,
-		GasPrice:         ftx.GasPrice,
-		GasLimit:         ftx.GasLimit,
-		DataField:        ftx.Data,
-		SignatureHex:     ftx.Signature,
-		ChainID:          ftx.ChainID,
-		Version:          ftx.Version,
-		Options:          ftx.Options,
-		Guardian:         ftx.GuardianAddr,
-		GuardianSigHex:   ftx.GuardianSignature,
+	innerTxs, err := tg.extractInnerTransactions(ftx.InnerTransactions)
+	if err != nil {
+		c.JSON(
+			http.StatusBadRequest,
+			shared.GenericAPIResponse{
+				Data:  nil,
+				Error: fmt.Sprintf("%s: %s", errors.ErrTxGenerationFailed.Error(), err.Error()),
+				Code:  shared.ReturnCodeRequestError,
+			},
+		)
+		return
 	}
-	start := time.Now()
-	tx, txHash, err := tg.getFacade().CreateTransaction(txArgs)
-	logging.LogAPIActionDurationIfNeeded(start, "API call: CreateTransaction")
+
+	if len(innerTxs) == 0 {
+		innerTxs = nil
+	}
+	tx, txHash, err := tg.createTransaction(&ftx, innerTxs)
 	if err != nil {
 		c.JSON(
 			http.StatusBadRequest,
@@ -304,7 +297,7 @@ func (tg *transactionGroup) sendTransaction(c *gin.Context) {
 		return
 	}
 
-	start = time.Now()
+	start := time.Now()
 	err = tg.getFacade().ValidateTransaction(tx)
 	logging.LogAPIActionDurationIfNeeded(start, "API call: ValidateTransaction")
 	if err != nil {
@@ -370,25 +363,23 @@ func (tg *transactionGroup) sendMultipleTransactions(c *gin.Context) {
 	var start time.Time
 	txsHashes := make(map[int]string)
 	for idx, receivedTx := range ftxs {
-		txArgs := &external.ArgsCreateTransaction{
-			Nonce:            receivedTx.Nonce,
-			Value:            receivedTx.Value,
-			Receiver:         receivedTx.Receiver,
-			ReceiverUsername: receivedTx.ReceiverUsername,
-			Sender:           receivedTx.Sender,
-			SenderUsername:   receivedTx.SenderUsername,
-			GasPrice:         receivedTx.GasPrice,
-			GasLimit:         receivedTx.GasLimit,
-			DataField:        receivedTx.Data,
-			SignatureHex:     receivedTx.Signature,
-			ChainID:          receivedTx.ChainID,
-			Version:          receivedTx.Version,
-			Options:          receivedTx.Options,
-			Guardian:         receivedTx.GuardianAddr,
-			GuardianSigHex:   receivedTx.GuardianSignature,
+		innerTxs, errExtractInnerTransactions := tg.extractInnerTransactions(receivedTx.InnerTransactions)
+		if errExtractInnerTransactions != nil {
+			c.JSON(
+				http.StatusBadRequest,
+				shared.GenericAPIResponse{
+					Data:  nil,
+					Error: fmt.Sprintf("%s: %s", errors.ErrTxGenerationFailed.Error(), err.Error()),
+					Code:  shared.ReturnCodeInternalError,
+				},
+			)
+			return
+		}
+
+		if len(innerTxs) == 0 {
+			innerTxs = nil
 		}
-		tx, txHash, err = tg.getFacade().CreateTransaction(txArgs)
-		logging.LogAPIActionDurationIfNeeded(start, "API call: CreateTransaction")
+		tx, txHash, err = tg.createTransaction(&receivedTx, innerTxs)
 		if err != nil {
 			continue
 		}
@@ -499,26 +490,23 @@ func (tg *transactionGroup) computeTransactionGasLimit(c *gin.Context) {
 		return
 	}
 
-	txArgs := &external.ArgsCreateTransaction{
-		Nonce:            ftx.Nonce,
-		Value:            ftx.Value,
-		Receiver:         ftx.Receiver,
-		ReceiverUsername: ftx.ReceiverUsername,
-		Sender:           ftx.Sender,
-		SenderUsername:   ftx.SenderUsername,
-		GasPrice:         ftx.GasPrice,
-		GasLimit:         ftx.GasLimit,
-		DataField:        ftx.Data,
-		SignatureHex:     ftx.Signature,
-		ChainID:          ftx.ChainID,
-		Version:          ftx.Version,
-		Options:          ftx.Options,
-		Guardian:         ftx.GuardianAddr,
-		GuardianSigHex:   ftx.GuardianSignature,
+	innerTxs, errExtractInnerTransactions := tg.extractInnerTransactions(ftx.InnerTransactions)
+	if errExtractInnerTransactions != nil {
+		c.JSON(
+			http.StatusBadRequest,
+			shared.GenericAPIResponse{
+				Data:  nil,
+				Error: fmt.Sprintf("%s: %s", errors.ErrTxGenerationFailed.Error(), errExtractInnerTransactions.Error()),
+				Code:  shared.ReturnCodeInternalError,
+			},
+		)
+		return
 	}
-	start := time.Now()
-	tx, _, err := tg.getFacade().CreateTransaction(txArgs)
-	logging.LogAPIActionDurationIfNeeded(start, "API call: CreateTransaction")
+
+	if len(innerTxs) == 0 {
+		innerTxs = nil
+	}
+	tx, _, err := tg.createTransaction(&ftx, innerTxs)
 	if err != nil {
 		c.JSON(
 			http.StatusInternalServerError,
@@ -531,7 +519,7 @@ func (tg *transactionGroup) computeTransactionGasLimit(c *gin.Context) {
 		return
 	}
 
-	start = time.Now()
+	start := time.Now()
 	cost, err := tg.getFacade().ComputeTransactionGasLimit(tx)
 	logging.LogAPIActionDurationIfNeeded(start, "API call: ComputeTransactionGasLimit")
 	if err != nil {
@@ -728,6 +716,33 @@ func (tg *transactionGroup) getTransactionsPoolNonceGapsForSender(sender string,
 	)
 }
 
+func (tg *transactionGroup) createTransaction(receivedTx *transaction.FrontendTransaction, innerTxs []*transaction.Transaction) (*transaction.Transaction, []byte, error) {
+	txArgs := &external.ArgsCreateTransaction{
+		Nonce:             receivedTx.Nonce,
+		Value:             receivedTx.Value,
+		Receiver:          receivedTx.Receiver,
+		ReceiverUsername:  receivedTx.ReceiverUsername,
+		Sender:            receivedTx.Sender,
+		SenderUsername:    receivedTx.SenderUsername,
+		GasPrice:          receivedTx.GasPrice,
+		GasLimit:          receivedTx.GasLimit,
+		DataField:         receivedTx.Data,
+		SignatureHex:      receivedTx.Signature,
+		ChainID:           receivedTx.ChainID,
+		Version:           receivedTx.Version,
+		Options:           receivedTx.Options,
+		Guardian:          receivedTx.GuardianAddr,
+		GuardianSigHex:    receivedTx.GuardianSignature,
+		Relayer:           receivedTx.Relayer,
+		InnerTransactions: innerTxs,
+	}
+	start := time.Now()
+	tx, txHash, err := tg.getFacade().CreateTransaction(txArgs)
+	logging.LogAPIActionDurationIfNeeded(start, "API call: CreateTransaction")
+
+	return tx, txHash, err
+}
+
 func validateQuery(sender, fields string, lastNonce, nonceGaps bool) error {
 	if fields != "" && lastNonce {
 		return errors.ErrFetchingLatestNonceCannotIncludeFields
@@ -825,6 +840,28 @@ func (tg *transactionGroup) getFacade() transactionFacadeHandler {
 	return tg.facade
 }
 
+func (tg *transactionGroup) extractInnerTransactions(
+	innerTransactions []*transaction.FrontendTransaction,
+) ([]*transaction.Transaction, error) {
+	innerTxs := make([]*transaction.Transaction, 0, len(innerTransactions))
+	if len(innerTransactions) != 0 {
+		for _, innerTx := range innerTransactions {
+			if len(innerTx.InnerTransactions) != 0 {
+				return innerTxs, errors.ErrRecursiveRelayedTxIsNotAllowed
+			}
+
+			newInnerTx, _, err := tg.createTransaction(innerTx, nil)
+			if err != nil {
+				return innerTxs, err
+			}
+
+			innerTxs = append(innerTxs, newInnerTx)
+		}
+	}
+
+	return innerTxs, nil
+}
+
 // UpdateFacade will update the facade
 func (tg *transactionGroup) UpdateFacade(newFacade interface{}) error {
 	if newFacade == nil {