Merge pull request #364 from multiversx/indexer-unexecutable-txs

Index unexecutable transactions

Author: miiu96

go.mod

@@ -8,7 +8,7 @@ require (
 	github.com/gin-gonic/gin v1.10.0
 	github.com/google/uuid v1.6.0
 	github.com/multiversx/mx-chain-communication-go v1.3.0
-	github.com/multiversx/mx-chain-core-go v1.4.2-0.20251208114845-28456d47841d
+	github.com/multiversx/mx-chain-core-go v1.4.2-0.20260130090903-7407465d70c6
 	github.com/multiversx/mx-chain-logger-go v1.1.0
 	github.com/multiversx/mx-chain-vm-common-go v1.6.0
 	github.com/prometheus/client_model v0.6.1

go.sum

@@ -118,8 +118,8 @@ github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o=
 github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
 github.com/multiversx/mx-chain-communication-go v1.3.0 h1:ziNM1dRuiR/7al2L/jGEA/a/hjurtJ/HEqgazHNt9P8=
 github.com/multiversx/mx-chain-communication-go v1.3.0/go.mod h1:gDVWn6zUW6aCN1YOm/FbbT5MUmhgn/L1Rmpl8EoH3Yg=
-github.com/multiversx/mx-chain-core-go v1.4.2-0.20251208114845-28456d47841d h1:BwBgijQGyCW4fbNyoGDky0mdRRPNuSbuTDlZZLxmMyQ=
-github.com/multiversx/mx-chain-core-go v1.4.2-0.20251208114845-28456d47841d/go.mod h1:IO+vspNan+gT0WOHnJ95uvWygiziHZvfXpff6KnxV7g=
+github.com/multiversx/mx-chain-core-go v1.4.2-0.20260130090903-7407465d70c6 h1:OpV/546No27cXiePXupD/GCPspka98AAHLUxJAy9CII=
+github.com/multiversx/mx-chain-core-go v1.4.2-0.20260130090903-7407465d70c6/go.mod h1:IO+vspNan+gT0WOHnJ95uvWygiziHZvfXpff6KnxV7g=
 github.com/multiversx/mx-chain-crypto-go v1.3.0 h1:0eK2bkDOMi8VbSPrB1/vGJSYT81IBtfL4zw+C4sWe/k=
 github.com/multiversx/mx-chain-crypto-go v1.3.0/go.mod h1:nPIkxxzyTP8IquWKds+22Q2OJ9W7LtusC7cAosz7ojM=
 github.com/multiversx/mx-chain-logger-go v1.1.0 h1:97x84A6L4RfCa6YOx1HpAFxZp1cf/WI0Qh112whgZNM=

process/elasticproc/block/blockProcessor.go

@@ -137,7 +137,8 @@ func (bp *blockProcessor) PrepareBlockForDB(obh *outport.OutportBlockWithHeader)
 
 	bp.addEpochStartInfoForMeta(obh.Header, elasticBlock)
 
-	elasticBlock.MiniBlocksDetails = prepareMiniBlockDetails(obh.Header.GetMiniBlockHeaderHandlers(), obh.BlockData.Body, obh.TransactionPool)
+	areProposedMBs := obh.Header.IsHeaderV3()
+	elasticBlock.MiniBlocksDetails = prepareMiniBlockDetails(obh.Header.GetMiniBlockHeaderHandlers(), obh.BlockData.Body, obh.TransactionPool, areProposedMBs)
 
 	appendBlockDetailsFromIntraShardMbs(elasticBlock, obh.BlockData.IntraShardMiniBlocks, obh.TransactionPool, len(obh.Header.GetMiniBlockHeaderHandlers()))
 
@@ -188,12 +189,12 @@ func (bp *blockProcessor) prepareExecutionResult(baseExecutionResult coreData.Ba
 
 	switch t := baseExecutionResult.(type) {
 	case *nodeBlock.MetaExecutionResult:
-		executionResult.MiniBlocksDetails = prepareMiniBlockDetails(t.GetMiniBlockHeadersHandlers(), executionResultData.Body, executionResultData.TransactionPool)
+		executionResult.MiniBlocksDetails = prepareMiniBlockDetails(t.GetMiniBlockHeadersHandlers(), executionResultData.Body, executionResultData.TransactionPool, false)
 		executionResult.AccumulatedFees = t.AccumulatedFees.String()
 		executionResult.DeveloperFees = t.DeveloperFees.String()
 		executionResult.TxCount = t.ExecutedTxCount
 	case *nodeBlock.ExecutionResult:
-		executionResult.MiniBlocksDetails = prepareMiniBlockDetails(t.GetMiniBlockHeadersHandlers(), executionResultData.Body, executionResultData.TransactionPool)
+		executionResult.MiniBlocksDetails = prepareMiniBlockDetails(t.GetMiniBlockHeadersHandlers(), executionResultData.Body, executionResultData.TransactionPool, false)
 		executionResult.AccumulatedFees = t.AccumulatedFees.String()
 		executionResult.DeveloperFees = t.DeveloperFees.String()
 		executionResult.TxCount = t.ExecutedTxCount
@@ -360,7 +361,7 @@ func (bp *blockProcessor) getEncodedMBSHashes(body *nodeBlock.Body, intraShardMb
 	return miniblocksHashes
 }
 
-func prepareMiniBlockDetails(mbHeaders []coreData.MiniBlockHeaderHandler, body *nodeBlock.Body, pool *outport.TransactionPool) []*data.MiniBlocksDetails {
+func prepareMiniBlockDetails(mbHeaders []coreData.MiniBlockHeaderHandler, body *nodeBlock.Body, pool *outport.TransactionPool, areProposed bool) []*data.MiniBlocksDetails {
 	mbsDetails := make([]*data.MiniBlocksDetails, 0, len(mbHeaders))
 	for idx, mbHeader := range mbHeaders {
 		mbType := nodeBlock.Type(mbHeader.GetTypeInt32())
@@ -369,17 +370,22 @@ func prepareMiniBlockDetails(mbHeaders []coreData.MiniBlockHeaderHandler, body *
 		}
 
 		txsHashes := body.MiniBlocks[idx].TxHashes
-		mbsDetails = append(mbsDetails, &data.MiniBlocksDetails{
-			IndexFirstProcessedTx:    mbHeader.GetIndexOfFirstTxProcessed(),
-			IndexLastProcessedTx:     mbHeader.GetIndexOfLastTxProcessed(),
-			MBIndex:                  idx,
-			ProcessingType:           nodeBlock.ProcessingType(mbHeader.GetProcessingType()).String(),
-			Type:                     mbType.String(),
-			SenderShardID:            mbHeader.GetSenderShardID(),
-			ReceiverShardID:          mbHeader.GetReceiverShardID(),
-			TxsHashes:                hexEncodeSlice(txsHashes),
-			ExecutionOrderTxsIndices: extractExecutionOrderIndicesFromPool(mbHeader, txsHashes, pool),
-		})
+		mbDetails := &data.MiniBlocksDetails{
+			IndexFirstProcessedTx: mbHeader.GetIndexOfFirstTxProcessed(),
+			IndexLastProcessedTx:  mbHeader.GetIndexOfLastTxProcessed(),
+			MBIndex:               idx,
+			ProcessingType:        nodeBlock.ProcessingType(mbHeader.GetProcessingType()).String(),
+			Type:                  mbType.String(),
+			SenderShardID:         mbHeader.GetSenderShardID(),
+			ReceiverShardID:       mbHeader.GetReceiverShardID(),
+			TxsHashes:             hexEncodeSlice(txsHashes),
+		}
+		if !areProposed {
+			mbDetails.ExecutionOrderTxsIndices = extractExecutionOrderIndicesFromPool(mbHeader, txsHashes, pool)
+		}
+
+		mbsDetails = append(mbsDetails, mbDetails)
+
 	}
 
 	return mbsDetails

process/elasticproc/transactions/transactionDBBuilder.go

@@ -9,6 +9,7 @@ import (
 	"github.com/multiversx/mx-chain-core-go/data/block"
 	"github.com/multiversx/mx-chain-core-go/data/outport"
 	"github.com/multiversx/mx-chain-core-go/data/receipt"
+	"github.com/multiversx/mx-chain-core-go/data/transaction"
 	"github.com/multiversx/mx-chain-es-indexer-go/data"
 	"github.com/multiversx/mx-chain-es-indexer-go/process/dataindexer"
 	"github.com/multiversx/mx-chain-es-indexer-go/process/elasticproc/converters"
@@ -35,6 +36,67 @@ func newTransactionDBBuilder(
 	}
 }
 
+func (dtb *dbTransactionBuilder) prepareUnexecutableTransaction(txHashHex string, tx *transaction.Transaction, headerData *data.HeaderData) *data.Transaction {
+	res := dtb.dataFieldParser.Parse(tx.Data, tx.SndAddr, tx.RcvAddr, headerData.NumberOfShards)
+	receiversAddr, _ := dtb.addressPubkeyConverter.EncodeSlice(res.Receivers)
+
+	valueNum, err := dtb.balanceConverter.ConvertBigValueToFloat(tx.Value)
+	if err != nil {
+		log.Warn("dbTransactionBuilder.prepareUnexecutableTransaction: cannot compute value as num", "value", tx.Value,
+			"hash", txHashHex, "error", err)
+	}
+
+	esdtValuesNum, err := dtb.balanceConverter.ComputeSliceOfStringsAsFloat(res.ESDTValues)
+	if err != nil {
+		log.Warn("dbTransactionBuilder.prepareTransaction: cannot compute esdt values as num",
+			"esdt values", res.ESDTValues, "hash", txHashHex, "error", err)
+	}
+
+	var esdtValues []string
+	if areESDTValuesOK(res.ESDTValues) {
+		esdtValues = res.ESDTValues
+	}
+	guardianAddress := ""
+	if len(tx.GuardianAddr) > 0 {
+		guardianAddress = dtb.addressPubkeyConverter.SilentEncode(tx.GuardianAddr, log)
+	}
+	relayedAddress := ""
+	if len(tx.RelayerAddr) > 0 {
+		relayedAddress = dtb.addressPubkeyConverter.SilentEncode(tx.RelayerAddr, log)
+	}
+
+	return &data.Transaction{
+		Hash:              txHashHex,
+		Nonce:             tx.Nonce,
+		Round:             headerData.Round,
+		Value:             tx.Value.String(),
+		Receiver:          dtb.addressPubkeyConverter.SilentEncode(tx.RcvAddr, log),
+		Sender:            dtb.addressPubkeyConverter.SilentEncode(tx.SndAddr, log),
+		ValueNum:          valueNum,
+		ReceiverShard:     sharding.ComputeShardID(tx.RcvAddr, headerData.NumberOfShards),
+		SenderShard:       sharding.ComputeShardID(tx.SndAddr, headerData.NumberOfShards),
+		GasPrice:          tx.GasPrice,
+		GasLimit:          tx.GasLimit,
+		Data:              tx.Data,
+		Signature:         hex.EncodeToString(tx.Signature),
+		Status:            transaction.TxStatusNotExecutable.String(),
+		IsScCall:          core.IsSmartContractAddress(tx.RcvAddr),
+		ESDTValues:        esdtValues,
+		ESDTValuesNum:     esdtValuesNum,
+		Receivers:         receiversAddr,
+		Version:           tx.Version,
+		GuardianAddress:   guardianAddress,
+		GuardianSignature: hex.EncodeToString(tx.GuardianSignature),
+		Operation:         res.Operation,
+		RelayedSignature:  hex.EncodeToString(tx.RelayerSignature),
+		RelayedAddr:       relayedAddress,
+		UUID:              converters.GenerateBase64UUID(),
+		Epoch:             headerData.Epoch,
+		Timestamp:         headerData.Timestamp,
+		TimestampMs:       headerData.TimestampMs,
+	}
+}
+
 func (dtb *dbTransactionBuilder) prepareTransaction(
 	txInfo *outport.TxInfo,
 	txHash []byte,

process/elasticproc/transactions/transactionDBBuilder_test.go

@@ -301,3 +301,65 @@ func TestGetMoveBalanceTransactionInvalid(t *testing.T) {
 	dbTx.UUID = ""
 	require.Equal(t, expectedTx, dbTx)
 }
+
+func TestPrepareUnexecutableTransaction(t *testing.T) {
+	t.Parallel()
+
+	txHash := []byte("txHash")
+	headerData := &data.HeaderData{
+		Timestamp:      1234,
+		TimestampMs:    1234000,
+		NumberOfShards: 3,
+	}
+	gasPrice := uint64(1000)
+	gasLimit := uint64(1000)
+	cp := createCommonProcessor()
+
+	tx := &transaction.Transaction{
+		Nonce:       1,
+		Value:       big.NewInt(1000),
+		RcvAddr:     []byte("receiver"),
+		SndAddr:     []byte("sender"),
+		GasPrice:    gasPrice,
+		GasLimit:    gasLimit,
+		Data:        []byte("data"),
+		ChainID:     []byte("1"),
+		Version:     1,
+		Signature:   []byte("signature"),
+		RcvUserName: []byte("rcv"),
+		SndUserName: []byte("snd"),
+	}
+
+	senderAddr, err := cp.addressPubkeyConverter.Encode(tx.RcvAddr)
+	require.Nil(t, err)
+	receiverAddr, err := cp.addressPubkeyConverter.Encode(tx.SndAddr)
+	require.Nil(t, err)
+
+	expectedTx := &data.Transaction{
+		Hash:          string(txHash),
+		Nonce:         tx.Nonce,
+		Round:         headerData.Round,
+		Value:         tx.Value.String(),
+		ValueNum:      1e-15,
+		Receiver:      senderAddr,
+		Sender:        receiverAddr,
+		GasPrice:      gasPrice,
+		GasLimit:      gasLimit,
+		Data:          tx.Data,
+		Signature:     hex.EncodeToString(tx.Signature),
+		Status:        transaction.TxStatusNotExecutable.String(),
+		ESDTValuesNum: []float64{},
+		Operation:     "transfer",
+		Version:       1,
+		Receivers:     []string{},
+		Timestamp:     1234,
+		TimestampMs:   1234000,
+		ReceiverShard: uint32(2),
+		SenderShard:   uint32(2),
+	}
+
+	dbTx := cp.prepareUnexecutableTransaction(string(txHash), tx, headerData)
+	dbTx.UUID = ""
+
+	require.Equal(t, expectedTx, dbTx)
+}

process/elasticproc/transactions/transactionsProcessor.go

@@ -117,6 +117,15 @@ func (tdp *txsDatabaseProcessor) PrepareTransactionsForDatabase(
 		}
 	}
 
+	for hashHex, tx := range pool.UnexecutableTransactions {
+		decodedHash, errD := hex.DecodeString(hashHex)
+		if errD != nil {
+			continue
+		}
+
+		normalTxs[string(decodedHash)] = tdp.txBuilder.prepareUnexecutableTransaction(hashHex, tx, headerData)
+	}
+
 	normalTxs = tdp.setTransactionSearchOrder(normalTxs)
 	dbReceipts := tdp.txsGrouper.groupReceipts(headerData, pool.Receipts)
 	dbSCResults := tdp.scrsProc.processSCRs(miniBlocks, headerData, pool.SmartContractResults)