Merge pull request #7346 from multiversx/fix-tx-endpoint-tx-type-relayed

sstanculeanu · web-flow · commit e3109b6b1c89 · 2025-10-17T12:31:31.000+03:00
Fix processing type field transaction endpoint
diff --git a/factory/disabled/txCoordinator.go b/factory/disabled/txCoordinator.go
@@ -29,6 +29,11 @@ func (txCoordinator *TxCoordinator) ComputeTransactionType(_ data.TransactionHan
 	return 0, 0, false
 }
 
+// ComputeTransactionTypeInEpoch does nothing as it is disabled
+func (txCoordinator *TxCoordinator) ComputeTransactionTypeInEpoch(_ data.TransactionHandler, _ uint32) (process.TransactionType, process.TransactionType, bool) {
+	return 0, 0, false
+}
+
 // RequestMiniBlocksAndTransactions does nothing as it is disabled
 func (txCoordinator *TxCoordinator) RequestMiniBlocksAndTransactions(_ data.HeaderHandler) {
 }
diff --git a/integrationTests/chainSimulator/relayedTx/relayedTx_test.go b/integrationTests/chainSimulator/relayedTx/relayedTx_test.go
@@ -1237,6 +1237,53 @@ func TestRelayedTransactionFeeField(t *testing.T) {
 	})
 }
 
+func TestRelayedTxCheckTxProcessingTypeAfterRelayedV1Disabled(t *testing.T) {
+	if testing.Short() {
+		t.Skip("this is not a short test")
+	}
+
+	const RelayedV1DisableEpoch = 3
+
+	cs := startChainSimulator(t, func(cfg *config.Configs) {
+		cfg.EpochConfig.EnableEpochs.RelayedTransactionsV1V2DisableEpoch = RelayedV1DisableEpoch
+	})
+	defer cs.Close()
+
+	initialBalance := big.NewInt(0).Mul(oneEGLD, big.NewInt(10))
+	relayer, err := cs.GenerateAndMintWalletAddress(0, initialBalance)
+	require.NoError(t, err)
+
+	snd, err := cs.GenerateAndMintWalletAddress(0, initialBalance)
+	require.NoError(t, err)
+
+	rcv, err := cs.GenerateAndMintWalletAddress(0, big.NewInt(0))
+	require.NoError(t, err)
+
+	err = cs.GenerateBlocks(1)
+	require.Nil(t, err)
+
+	userTx := generateTransaction(snd.Bytes, 0, rcv.Bytes, oneEGLD, "d", minGasLimit+gasPerDataByte)
+	buff, err := json.Marshal(userTx)
+	require.NoError(t, err)
+
+	txData := []byte("relayedTx@" + hex.EncodeToString(buff))
+	gasLimit := minGasLimit + len(txData)*gasPerDataByte + int(userTx.GasLimit)
+	relayedTx := generateTransaction(relayer.Bytes, 0, snd.Bytes, big.NewInt(0), string(txData), uint64(gasLimit))
+
+	result, err := cs.SendTxAndGenerateBlockTilTxIsExecuted(relayedTx, maxNumOfBlocksToGenerateWhenExecutingTx)
+	require.NoError(t, err)
+	require.Equal(t, process.RelayedTx.String(), result.ProcessingTypeOnSource)
+	require.Equal(t, process.RelayedTx.String(), result.ProcessingTypeOnSource)
+
+	err = cs.GenerateBlocksUntilEpochIsReached(RelayedV1DisableEpoch)
+	require.NoError(t, err)
+
+	result, err = cs.GetNodeHandler(0).GetFacadeHandler().GetTransaction(result.Hash, true)
+	require.NoError(t, err)
+	require.Equal(t, process.RelayedTx.String(), result.ProcessingTypeOnSource)
+	require.Equal(t, process.RelayedTx.String(), result.ProcessingTypeOnSource)
+}
+
 func TestRegularMoveBalanceWithRefundReceipt(t *testing.T) {
 	if testing.Short() {
 		t.Skip("this is not a short test")
diff --git a/integrationTests/mock/transactionCoordinatorMock.go b/integrationTests/mock/transactionCoordinatorMock.go
@@ -34,6 +34,7 @@ type TransactionCoordinatorMock struct {
 	GetAllIntermediateTxsCalled                          func() map[block.Type]map[string]data.TransactionHandler
 	AddTxsFromMiniBlocksCalled                           func(miniBlocks block.MiniBlockSlice)
 	AddTransactionsCalled                                func(txHandlers []data.TransactionHandler, blockType block.Type)
+	ComputeTransactionTypeInEpochCalled                  func(tx data.TransactionHandler, epoch uint32) (process.TransactionType, process.TransactionType, bool)
 }
 
 // GetAllCurrentLogs -
@@ -63,6 +64,15 @@ func (tcm *TransactionCoordinatorMock) ComputeTransactionType(tx data.Transactio
 	return tcm.ComputeTransactionTypeCalled(tx)
 }
 
+// ComputeTransactionTypeInEpoch -
+func (tcm *TransactionCoordinatorMock) ComputeTransactionTypeInEpoch(tx data.TransactionHandler, epoch uint32) (process.TransactionType, process.TransactionType, bool) {
+	if tcm.ComputeTransactionTypeInEpochCalled == nil {
+		return process.MoveBalance, process.MoveBalance, false
+	}
+
+	return tcm.ComputeTransactionTypeInEpochCalled(tx, epoch)
+}
+
 // RequestMiniBlocksAndTransactions -
 func (tcm *TransactionCoordinatorMock) RequestMiniBlocksAndTransactions(header data.HeaderHandler) {
 	if tcm.RequestMiniBlocksAndTransactionsCalled == nil {
diff --git a/node/external/transactionAPI/apiTransactionProcessor.go b/node/external/transactionAPI/apiTransactionProcessor.go
@@ -189,7 +189,7 @@ func (atp *apiTransactionProcessor) PopulateComputedFields(tx *transaction.ApiTr
 }
 
 func (atp *apiTransactionProcessor) populateComputedFieldsProcessingType(tx *transaction.ApiTransactionResult) {
-	typeOnSource, typeOnDestination, _ := atp.txTypeHandler.ComputeTransactionType(tx.Tx)
+	typeOnSource, typeOnDestination, _ := atp.txTypeHandler.ComputeTransactionTypeInEpoch(tx.Tx, tx.Epoch)
 	tx.ProcessingTypeOnSource = typeOnSource.String()
 	tx.ProcessingTypeOnDestination = typeOnDestination.String()
 }
diff --git a/node/external/transactionAPI/apiTransactionProcessor_test.go b/node/external/transactionAPI/apiTransactionProcessor_test.go
@@ -1337,7 +1337,7 @@ func TestApiTransactionProcessor_GetTransactionPopulatesComputedFields(t *testin
 	})
 
 	t.Run("ProcessingType", func(t *testing.T) {
-		txTypeHandler.ComputeTransactionTypeCalled = func(data.TransactionHandler) (process.TransactionType, process.TransactionType, bool) {
+		txTypeHandler.ComputeTransactionTypeInEpochCalled = func(data.TransactionHandler, uint32) (process.TransactionType, process.TransactionType, bool) {
 			return process.MoveBalance, process.SCDeployment, false
 		}
 
@@ -1350,7 +1350,7 @@ func TestApiTransactionProcessor_GetTransactionPopulatesComputedFields(t *testin
 	})
 
 	t.Run("ProcessingType (with relayed v3)", func(t *testing.T) {
-		txTypeHandler.ComputeTransactionTypeCalled = func(data.TransactionHandler) (process.TransactionType, process.TransactionType, bool) {
+		txTypeHandler.ComputeTransactionTypeInEpochCalled = func(data.TransactionHandler, uint32) (process.TransactionType, process.TransactionType, bool) {
 			return process.MoveBalance, process.SCDeployment, true
 		}
 
@@ -1394,7 +1394,7 @@ func TestApiTransactionProcessor_PopulateComputedFields(t *testing.T) {
 	require.Nil(t, err)
 	require.NotNil(t, processor)
 
-	txTypeHandler.ComputeTransactionTypeCalled = func(data.TransactionHandler) (process.TransactionType, process.TransactionType, bool) {
+	txTypeHandler.ComputeTransactionTypeInEpochCalled = func(data.TransactionHandler, uint32) (process.TransactionType, process.TransactionType, bool) {
 		return process.MoveBalance, process.SCDeployment, false
 	}
 
diff --git a/process/coordinator/transactionType.go b/process/coordinator/transactionType.go
@@ -76,8 +76,19 @@ func NewTxTypeHandler(
 	return tc, nil
 }
 
+// ComputeTransactionTypeInEpoch calculates the transaction type based on the provided epoch
+func (tth *txTypeHandler) ComputeTransactionTypeInEpoch(tx data.TransactionHandler, epoch uint32) (process.TransactionType, process.TransactionType, bool) {
+	return tth.computeTransactionType(tx, epoch)
+}
+
 // ComputeTransactionType calculates the transaction type
 func (tth *txTypeHandler) ComputeTransactionType(tx data.TransactionHandler) (process.TransactionType, process.TransactionType, bool) {
+	currentEpoch := tth.enableEpochsHandler.GetCurrentEpoch()
+
+	return tth.computeTransactionType(tx, currentEpoch)
+}
+
+func (tth *txTypeHandler) computeTransactionType(tx data.TransactionHandler, epoch uint32) (process.TransactionType, process.TransactionType, bool) {
 	err := tth.checkTxValidity(tx)
 	if err != nil {
 		return process.InvalidTransaction, process.InvalidTransaction, false
@@ -99,7 +110,7 @@ func (tth *txTypeHandler) ComputeTransactionType(tx data.TransactionHandler) (pr
 	funcName, args := tth.getFunctionFromArguments(tx.GetData())
 	isBuiltInFunction := tth.isBuiltInFunctionCall(funcName)
 	if isBuiltInFunction {
-		if tth.isSCCallAfterBuiltIn(funcName, args, tx) {
+		if tth.isSCCallAfterBuiltIn(funcName, args, tx, epoch) {
 			return process.BuiltInFunctionCall, process.SCInvoking, isRelayedV3
 		}
 
@@ -114,11 +125,11 @@ func (tth *txTypeHandler) ComputeTransactionType(tx data.TransactionHandler) (pr
 		return process.MoveBalance, process.MoveBalance, isRelayedV3
 	}
 
-	if tth.isRelayedTransactionV1(funcName) {
+	if tth.isRelayedTransactionV1(funcName, epoch) {
 		return process.RelayedTx, process.RelayedTx, isRelayedV3 // this should never be reached with both relayed v1 and relayed v3
 	}
 
-	if tth.isRelayedTransactionV2(funcName) {
+	if tth.isRelayedTransactionV2(funcName, epoch) {
 		return process.RelayedTxV2, process.RelayedTxV2, isRelayedV3 // this should never be reached with both relayed v2 and relayed v3
 	}
 
@@ -143,8 +154,8 @@ func isCallOfType(tx data.TransactionHandler, callType vm.CallType) bool {
 	return scr.CallType == callType
 }
 
-func (tth *txTypeHandler) isSCCallAfterBuiltIn(function string, args [][]byte, tx data.TransactionHandler) bool {
-	isTransferAndAsyncCallbackFixFlagSet := tth.enableEpochsHandler.IsFlagEnabled(common.ESDTMetadataContinuousCleanupFlag)
+func (tth *txTypeHandler) isSCCallAfterBuiltIn(function string, args [][]byte, tx data.TransactionHandler, epoch uint32) bool {
+	isTransferAndAsyncCallbackFixFlagSet := tth.enableEpochsHandler.IsFlagEnabledInEpoch(common.ESDTMetadataContinuousCleanupFlag, epoch)
 	if isTransferAndAsyncCallbackFixFlagSet && isCallOfType(tx, vm.AsynchronousCallBack) {
 		return true
 	}
@@ -184,17 +195,17 @@ func (tth *txTypeHandler) isBuiltInFunctionCall(functionName string) bool {
 	return function.IsActive()
 }
 
-func (tth *txTypeHandler) isRelayedTransactionV1(functionName string) bool {
-	areRelayedDisabled := tth.enableEpochsHandler.IsFlagEnabled(common.RelayedTransactionsV1V2DisableFlag)
+func (tth *txTypeHandler) isRelayedTransactionV1(functionName string, epoch uint32) bool {
+	areRelayedDisabled := tth.enableEpochsHandler.IsFlagEnabledInEpoch(common.RelayedTransactionsV1V2DisableFlag, epoch)
 	if areRelayedDisabled {
 		return false
 	}
 
 	return functionName == core.RelayedTransaction
 }
 
-func (tth *txTypeHandler) isRelayedTransactionV2(functionName string) bool {
-	areRelayedDisabled := tth.enableEpochsHandler.IsFlagEnabled(common.RelayedTransactionsV1V2DisableFlag)
+func (tth *txTypeHandler) isRelayedTransactionV2(functionName string, epoch uint32) bool {
+	areRelayedDisabled := tth.enableEpochsHandler.IsFlagEnabledInEpoch(common.RelayedTransactionsV1V2DisableFlag, epoch)
 	if areRelayedDisabled {
 		return false
 	}
diff --git a/process/coordinator/transactionType_test.go b/process/coordinator/transactionType_test.go
@@ -491,7 +491,11 @@ func TestTxTypeHandler_ComputeTransactionDisabledRelayed(t *testing.T) {
 	tx.Value = big.NewInt(45)
 
 	arg := createMockArguments()
-	arg.EnableEpochsHandler = enableEpochsHandlerMock.NewEnableEpochsHandlerStub(common.RelayedTransactionsV1V2DisableFlag)
+	arg.EnableEpochsHandler = &enableEpochsHandlerMock.EnableEpochsHandlerStub{
+		IsFlagEnabledInEpochCalled: func(flag core.EnableEpochFlag, epoch uint32) bool {
+			return true
+		},
+	}
 	arg.PubkeyConverter = &testscommon.PubkeyConverterStub{
 		LenCalled: func() int {
 			return len(tx.RcvAddr)
diff --git a/process/disabled/txTypeHandler.go b/process/disabled/txTypeHandler.go
diff --git a/process/interface.go b/process/interface.go
@@ -71,6 +71,7 @@ type SmartContractProcessorFacade interface {
 // TxTypeHandler is an interface to calculate the transaction type
 type TxTypeHandler interface {
 	ComputeTransactionType(tx data.TransactionHandler) (TransactionType, TransactionType, bool)
+	ComputeTransactionTypeInEpoch(tx data.TransactionHandler, epoch uint32) (TransactionType, TransactionType, bool)
 	IsInterfaceNil() bool
 }
 
diff --git a/testscommon/scProcessorMock.go b/testscommon/scProcessorMock.go
@@ -18,6 +18,16 @@ type SCProcessorMock struct {
 	ProcessIfErrorCalled                   func(acntSnd state.UserAccountHandler, txHash []byte, tx data.TransactionHandler, returnCode string, returnMessage []byte, snapshot int, gasLocked uint64) error
 	IsPayableCalled                        func(sndAddress, recvAddress []byte) (bool, error)
 	CheckBuiltinFunctionIsExecutableCalled func(expectedBuiltinFunction string, tx data.TransactionHandler) error
+	ComputeTransactionTypeInEpochCalled    func(tx data.TransactionHandler, epoch uint32) (process.TransactionType, process.TransactionType, bool)
+}
+
+// ComputeTransactionTypeInEpoch -
+func (sc *SCProcessorMock) ComputeTransactionTypeInEpoch(tx data.TransactionHandler, epoch uint32) (process.TransactionType, process.TransactionType, bool) {
+	if sc.ComputeTransactionTypeInEpochCalled == nil {
+		return process.MoveBalance, process.MoveBalance, false
+	}
+
+	return sc.ComputeTransactionTypeInEpochCalled(tx, epoch)
 }
 
 // IsPayable -
diff --git a/testscommon/transactionCoordinatorMock.go b/testscommon/transactionCoordinatorMock.go
@@ -34,10 +34,20 @@ type TransactionCoordinatorMock struct {
 	GetAllIntermediateTxsCalled                          func() map[block.Type]map[string]data.TransactionHandler
 	AddTxsFromMiniBlocksCalled                           func(miniBlocks block.MiniBlockSlice)
 	AddTransactionsCalled                                func(txHandlers []data.TransactionHandler, blockType block.Type)
+	ComputeTransactionTypeInEpochCalled                  func(tx data.TransactionHandler, epoch uint32) (process.TransactionType, process.TransactionType, bool)
 
 	miniBlocks []*block.MiniBlock
 }
 
+// ComputeTransactionTypeInEpoch -
+func (tcm *TransactionCoordinatorMock) ComputeTransactionTypeInEpoch(tx data.TransactionHandler, epoch uint32) (process.TransactionType, process.TransactionType, bool) {
+	if tcm.ComputeTransactionTypeInEpochCalled == nil {
+		return process.MoveBalance, process.MoveBalance, false
+	}
+
+	return tcm.ComputeTransactionTypeInEpochCalled(tx, epoch)
+}
+
 // GetAllCurrentLogs -
 func (tcm *TransactionCoordinatorMock) GetAllCurrentLogs() []*data.LogData {
 	return nil
diff --git a/testscommon/txTypeHandlerMock.go b/testscommon/txTypeHandlerMock.go
@@ -7,7 +7,17 @@ import (
 
 // TxTypeHandlerMock -
 type TxTypeHandlerMock struct {
-	ComputeTransactionTypeCalled func(tx data.TransactionHandler) (process.TransactionType, process.TransactionType, bool)
+	ComputeTransactionTypeCalled        func(tx data.TransactionHandler) (process.TransactionType, process.TransactionType, bool)
+	ComputeTransactionTypeInEpochCalled func(tx data.TransactionHandler, epoch uint32) (process.TransactionType, process.TransactionType, bool)
+}
+
+// ComputeTransactionTypeInEpoch -
+func (th *TxTypeHandlerMock) ComputeTransactionTypeInEpoch(tx data.TransactionHandler, epoch uint32) (process.TransactionType, process.TransactionType, bool) {
+	if th.ComputeTransactionTypeInEpochCalled == nil {
+		return process.MoveBalance, process.MoveBalance, false
+	}
+
+	return th.ComputeTransactionTypeInEpochCalled(tx, epoch)
 }
 
 // ComputeTransactionType -

Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,11 @@ func (txCoordinator *TxCoordinator) ComputeTransactionType(_ data.TransactionHan`
`29`	`29`	`return 0, 0, false`
`30`	`30`	`}`
`31`	`31`
	`32`	`+// ComputeTransactionTypeInEpoch does nothing as it is disabled`
	`33`	`+func (txCoordinator *TxCoordinator) ComputeTransactionTypeInEpoch(_ data.TransactionHandler, _ uint32) (process.TransactionType, process.TransactionType, bool) {`
	`34`	`+ return 0, 0, false`
	`35`	`+}`
	`36`	`+`
`32`	`37`	`// RequestMiniBlocksAndTransactions does nothing as it is disabled`
`33`	`38`	`func (txCoordinator *TxCoordinator) RequestMiniBlocksAndTransactions(_ data.HeaderHandler) {`
`34`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -189,7 +189,7 @@ func (atp apiTransactionProcessor) PopulateComputedFields(tx transaction.ApiTr`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`func (atp apiTransactionProcessor) populateComputedFieldsProcessingType(tx transaction.ApiTransactionResult) {`
`192`		`- typeOnSource, typeOnDestination, _ := atp.txTypeHandler.ComputeTransactionType(tx.Tx)`
	`192`	`+ typeOnSource, typeOnDestination, _ := atp.txTypeHandler.ComputeTransactionTypeInEpoch(tx.Tx, tx.Epoch)`
`193`	`193`	`tx.ProcessingTypeOnSource = typeOnSource.String()`
`194`	`194`	`tx.ProcessingTypeOnDestination = typeOnDestination.String()`
`195`	`195`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1337,7 +1337,7 @@ func TestApiTransactionProcessor_GetTransactionPopulatesComputedFields(t *testin`
`1337`	`1337`	`})`
`1338`	`1338`
`1339`	`1339`	`t.Run("ProcessingType", func(t *testing.T) {`
`1340`		`- txTypeHandler.ComputeTransactionTypeCalled = func(data.TransactionHandler) (process.TransactionType, process.TransactionType, bool) {`
	`1340`	`+ txTypeHandler.ComputeTransactionTypeInEpochCalled = func(data.TransactionHandler, uint32) (process.TransactionType, process.TransactionType, bool) {`
`1341`	`1341`	`return process.MoveBalance, process.SCDeployment, false`
`1342`	`1342`	`}`
`1343`	`1343`
`@@ -1350,7 +1350,7 @@ func TestApiTransactionProcessor_GetTransactionPopulatesComputedFields(t *testin`
`1350`	`1350`	`})`
`1351`	`1351`
`1352`	`1352`	`t.Run("ProcessingType (with relayed v3)", func(t *testing.T) {`
`1353`		`- txTypeHandler.ComputeTransactionTypeCalled = func(data.TransactionHandler) (process.TransactionType, process.TransactionType, bool) {`
	`1353`	`+ txTypeHandler.ComputeTransactionTypeInEpochCalled = func(data.TransactionHandler, uint32) (process.TransactionType, process.TransactionType, bool) {`
`1354`	`1354`	`return process.MoveBalance, process.SCDeployment, true`
`1355`	`1355`	`}`
`1356`	`1356`
`@@ -1394,7 +1394,7 @@ func TestApiTransactionProcessor_PopulateComputedFields(t *testing.T) {`
`1394`	`1394`	`require.Nil(t, err)`
`1395`	`1395`	`require.NotNil(t, processor)`
`1396`	`1396`
`1397`		`- txTypeHandler.ComputeTransactionTypeCalled = func(data.TransactionHandler) (process.TransactionType, process.TransactionType, bool) {`
	`1397`	`+ txTypeHandler.ComputeTransactionTypeInEpochCalled = func(data.TransactionHandler, uint32) (process.TransactionType, process.TransactionType, bool) {`
`1398`	`1398`	`return process.MoveBalance, process.SCDeployment, false`
`1399`	`1399`	`}`
`1400`	`1400`
Original file line number	Diff line number	Diff line change
`@@ -71,6 +71,7 @@ type SmartContractProcessorFacade interface {`
`71`	`71`	`// TxTypeHandler is an interface to calculate the transaction type`
`72`	`72`	`type TxTypeHandler interface {`
`73`	`73`	`ComputeTransactionType(tx data.TransactionHandler) (TransactionType, TransactionType, bool)`
	`74`	`+ ComputeTransactionTypeInEpoch(tx data.TransactionHandler, epoch uint32) (TransactionType, TransactionType, bool)`
`74`	`75`	`IsInterfaceNil() bool`
`75`	`76`	`}`
`76`	`77`