Separate fee handling for inner tx of type move balance

cmd/node/config/enableEpochs.toml

@@ -281,6 +281,9 @@
     # RelayedTransactionsV3EnableEpoch represents the epoch when the relayed transactions V3 will be enabled
     RelayedTransactionsV3EnableEpoch = 3
 
+    # FixRelayedMoveBalanceEnableEpoch represents the epoch when the fix for relayed for move balance will be enabled
+    FixRelayedMoveBalanceEnableEpoch = 3
+
     # BLSMultiSignerEnableEpoch represents the activation epoch for different types of BLS multi-signers
     BLSMultiSignerEnableEpoch = [
         { EnableEpoch = 0, Type = "no-KOSK" },

common/constants.go

@@ -479,6 +479,9 @@ const (
 	// MetricRelayedTransactionsV3EnableEpoch represents the epoch when the relayed transactions v3 is enabled
 	MetricRelayedTransactionsV3EnableEpoch = "erd_relayed_transactions_v3_enable_epoch"
 
+	// MetricFixRelayedMoveBalanceEnableEpoch represents the epoch when the fix for relayed move balance is enabled
+	MetricFixRelayedMoveBalanceEnableEpoch = "erd_fix_relayed_move_balance_enable_epoch"
+
 	// MetricUnbondTokensV2EnableEpoch represents the epoch when the unbond tokens v2 is applied
 	MetricUnbondTokensV2EnableEpoch = "erd_unbond_tokens_v2_enable_epoch"
 

common/enablers/enableEpochsHandler.go

@@ -131,6 +131,7 @@ func (handler *enableEpochsHandler) EpochConfirmed(epoch uint32, _ uint64) {
 	handler.setFlagValue(epoch >= handler.enableEpochsConfig.SCProcessorV2EnableEpoch, handler.scProcessorV2Flag, "scProcessorV2Flag", epoch, handler.enableEpochsConfig.SCProcessorV2EnableEpoch)
 	handler.setFlagValue(epoch >= handler.enableEpochsConfig.DynamicGasCostForDataTrieStorageLoadEnableEpoch, handler.dynamicGasCostForDataTrieStorageLoadFlag, "dynamicGasCostForDataTrieStorageLoadFlag", epoch, handler.enableEpochsConfig.DynamicGasCostForDataTrieStorageLoadEnableEpoch)
 	handler.setFlagValue(epoch >= handler.enableEpochsConfig.RelayedTransactionsV3EnableEpoch, handler.relayedTransactionsV3Flag, "relayedTransactionsV3Flag", epoch, handler.enableEpochsConfig.RelayedTransactionsV3EnableEpoch)
+	handler.setFlagValue(epoch >= handler.enableEpochsConfig.FixRelayedMoveBalanceEnableEpoch, handler.fixRelayedMoveBalanceFlag, "fixRelayedMoveBalanceFlag", epoch, handler.enableEpochsConfig.FixRelayedMoveBalanceEnableEpoch)
 }
 
 func (handler *enableEpochsHandler) setFlagValue(value bool, flag *atomic.Flag, flagName string, epoch uint32, flagEpoch uint32) {

common/enablers/enableEpochsHandler_test.go

@@ -105,6 +105,7 @@ func createEnableEpochsConfig() config.EnableEpochs {
 		DeterministicSortOnValidatorsInfoEnableEpoch:      79,
 		ScToScLogEventEnableEpoch:                         88,
 		RelayedTransactionsV3EnableEpoch:                  89,
+		FixRelayedMoveBalanceEnableEpoch:                  90,
 	}
 }
 
@@ -249,6 +250,7 @@ func TestNewEnableEpochsHandler_EpochConfirmed(t *testing.T) {
 		assert.True(t, handler.IsESDTNFTImprovementV1FlagEnabled())
 		assert.True(t, handler.FixDelegationChangeOwnerOnAccountEnabled())
 		assert.True(t, handler.IsRelayedTransactionsV3FlagEnabled())
+		assert.True(t, handler.IsFixRelayedMoveBalanceFlagEnabled())
 	})
 	t.Run("flags with == condition should not be set, the ones with >= should be set", func(t *testing.T) {
 		t.Parallel()
@@ -369,6 +371,7 @@ func TestNewEnableEpochsHandler_EpochConfirmed(t *testing.T) {
 		assert.True(t, handler.IsESDTNFTImprovementV1FlagEnabled())
 		assert.True(t, handler.FixDelegationChangeOwnerOnAccountEnabled())
 		assert.True(t, handler.IsRelayedTransactionsV3FlagEnabled())
+		assert.True(t, handler.IsFixRelayedMoveBalanceFlagEnabled())
 	})
 	t.Run("flags with < should be set", func(t *testing.T) {
 		t.Parallel()
@@ -484,6 +487,7 @@ func TestNewEnableEpochsHandler_EpochConfirmed(t *testing.T) {
 		assert.False(t, handler.IsESDTNFTImprovementV1FlagEnabled())
 		assert.False(t, handler.FixDelegationChangeOwnerOnAccountEnabled())
 		assert.False(t, handler.IsRelayedTransactionsV3FlagEnabled())
+		assert.False(t, handler.IsFixRelayedMoveBalanceFlagEnabled())
 	})
 }
 

common/enablers/epochFlags.go

@@ -103,6 +103,7 @@ type epochFlagsHolder struct {
 	fixDelegationChangeOwnerOnAccountFlag       *atomic.Flag
 	dynamicGasCostForDataTrieStorageLoadFlag    *atomic.Flag
 	relayedTransactionsV3Flag                   *atomic.Flag
+	fixRelayedMoveBalanceFlag                   *atomic.Flag
 }
 
 func newEpochFlagsHolder() *epochFlagsHolder {
@@ -205,6 +206,7 @@ func newEpochFlagsHolder() *epochFlagsHolder {
 		fixDelegationChangeOwnerOnAccountFlag:       &atomic.Flag{},
 		dynamicGasCostForDataTrieStorageLoadFlag:    &atomic.Flag{},
 		relayedTransactionsV3Flag:                   &atomic.Flag{},
+		fixRelayedMoveBalanceFlag:                   &atomic.Flag{},
 	}
 }
 
@@ -746,6 +748,11 @@ func (holder *epochFlagsHolder) IsRelayedTransactionsV3FlagEnabled() bool {
 	return holder.relayedTransactionsV3Flag.IsSet()
 }
 
+// IsFixRelayedMoveBalanceFlagEnabled returns true if fixRelayedMoveBalanceFlag is enabled
+func (holder *epochFlagsHolder) IsFixRelayedMoveBalanceFlagEnabled() bool {
+	return holder.fixRelayedMoveBalanceFlag.IsSet()
+}
+
 // IsDynamicGasCostForDataTrieStorageLoadEnabled returns true if dynamicGasCostForDataTrieStorageLoadFlag is enabled
 func (holder *epochFlagsHolder) IsDynamicGasCostForDataTrieStorageLoadEnabled() bool {
 	return holder.dynamicGasCostForDataTrieStorageLoadFlag.IsSet()

common/interface.go

@@ -396,6 +396,7 @@ type EnableEpochsHandler interface {
 	IsDynamicGasCostForDataTrieStorageLoadEnabled() bool
 	FixDelegationChangeOwnerOnAccountEnabled() bool
 	IsRelayedTransactionsV3FlagEnabled() bool
+	IsFixRelayedMoveBalanceFlagEnabled() bool
 
 	IsInterfaceNil() bool
 }

config/epochConfig.go

@@ -106,6 +106,7 @@ type EnableEpochs struct {
 	FixDelegationChangeOwnerOnAccountEnableEpoch      uint32
 	DynamicGasCostForDataTrieStorageLoadEnableEpoch   uint32
 	RelayedTransactionsV3EnableEpoch                  uint32
+	FixRelayedMoveBalanceEnableEpoch                  uint32
 	BLSMultiSignerEnableEpoch                         []MultiSignerConfig
 }
 

config/tomlConfig_test.go

@@ -820,6 +820,9 @@ func TestEnableEpochConfig(t *testing.T) {
     # RelayedTransactionsV3EnableEpoch represents the epoch when the relayed transactions V3 will be enabled
     RelayedTransactionsV3EnableEpoch = 89
 
+    # FixRelayedMoveBalanceEnableEpoch represents the epoch when the fix for relayed for move balance will be enabled
+    FixRelayedMoveBalanceEnableEpoch = 90
+
     # MaxNodesChangeEnableEpoch holds configuration for changing the maximum number of nodes and the enabling epoch
     MaxNodesChangeEnableEpoch = [
         { EpochEnable = 44, MaxNumNodes = 2169, NodesToShufflePerShard = 80 },
@@ -929,6 +932,7 @@ func TestEnableEpochConfig(t *testing.T) {
 			FixDelegationChangeOwnerOnAccountEnableEpoch:      87,
 			ScToScLogEventEnableEpoch:                         88,
 			RelayedTransactionsV3EnableEpoch:                  89,
+			FixRelayedMoveBalanceEnableEpoch:                  90,
 			MaxNodesChangeEnableEpoch: []MaxNodesChangeConfig{
 				{
 					EpochEnable:            44,

genesis/process/shardGenesisBlockCreator.go

@@ -150,6 +150,7 @@ func createGenesisConfig() config.EnableEpochs {
 		SetGuardianEnableEpoch:                            unreachableEpoch,
 		ScToScLogEventEnableEpoch:                         unreachableEpoch,
 		RelayedTransactionsV3EnableEpoch:                  unreachableEpoch,
+		FixRelayedMoveBalanceEnableEpoch:                  unreachableEpoch,
 	}
 }
 

integrationTests/multiShard/relayedTx/common.go

@@ -59,7 +59,7 @@ func CreateAndSendRelayedAndUserTx(
 	value *big.Int,
 	gasLimit uint64,
 	txData []byte,
-) *transaction.Transaction {
+) (*transaction.Transaction, *transaction.Transaction) {
 	txDispatcherNode := getNodeWithinSameShardAsPlayer(nodes, relayer.Address)
 
 	userTx := createUserTx(player, rcvAddr, value, gasLimit, txData, nil)
@@ -70,7 +70,7 @@ func CreateAndSendRelayedAndUserTx(
 		fmt.Println(err.Error())
 	}
 
-	return relayedTx
+	return relayedTx, userTx
 }
 
 // CreateAndSendRelayedAndUserTxV2 will create and send a relayed user transaction for relayed v2
@@ -82,7 +82,7 @@ func CreateAndSendRelayedAndUserTxV2(
 	value *big.Int,
 	gasLimit uint64,
 	txData []byte,
-) *transaction.Transaction {
+) (*transaction.Transaction, *transaction.Transaction) {
 	txDispatcherNode := getNodeWithinSameShardAsPlayer(nodes, relayer.Address)
 
 	userTx := createUserTx(player, rcvAddr, value, 0, txData, nil)
@@ -93,7 +93,7 @@ func CreateAndSendRelayedAndUserTxV2(
 		fmt.Println(err.Error())
 	}
 
-	return relayedTx
+	return relayedTx, userTx
 }
 
 // CreateAndSendRelayedAndUserTxV3 will create and send a relayed user transaction for relayed v3
@@ -105,7 +105,7 @@ func CreateAndSendRelayedAndUserTxV3(
 	value *big.Int,
 	gasLimit uint64,
 	txData []byte,
-) *transaction.Transaction {
+) (*transaction.Transaction, *transaction.Transaction) {
 	txDispatcherNode := getNodeWithinSameShardAsPlayer(nodes, relayer.Address)
 
 	userTx := createUserTx(player, rcvAddr, value, gasLimit, txData, relayer.Address)
@@ -116,7 +116,7 @@ func CreateAndSendRelayedAndUserTxV3(
 		fmt.Println(err.Error())
 	}
 
-	return relayedTx
+	return relayedTx, userTx
 }
 
 func createUserTx(
@@ -142,6 +142,7 @@ func createUserTx(
 	txBuff, _ := tx.GetDataForSigning(integrationTests.TestAddressPubkeyConverter, integrationTests.TestTxSignMarshalizer, integrationTests.TestTxSignHasher)
 	tx.Signature, _ = player.SingleSigner.Sign(player.SkTxSign, txBuff)
 	player.Nonce++
+	player.Balance.Sub(player.Balance, value)
 	return tx
 }
 
@@ -169,10 +170,11 @@ func createRelayedTx(
 	txBuff, _ := tx.GetDataForSigning(integrationTests.TestAddressPubkeyConverter, integrationTests.TestTxSignMarshalizer, integrationTests.TestTxSignHasher)
 	tx.Signature, _ = relayer.SingleSigner.Sign(relayer.SkTxSign, txBuff)
 	relayer.Nonce++
-	txFee := economicsFee.ComputeTxFee(tx)
-	relayer.Balance.Sub(relayer.Balance, txFee)
+
 	relayer.Balance.Sub(relayer.Balance, tx.Value)
 
+	subFeesFromRelayer(tx, userTx, economicsFee, relayer)
+
 	return tx
 }
 
@@ -198,10 +200,11 @@ func createRelayedTxV2(
 	txBuff, _ := tx.GetDataForSigning(integrationTests.TestAddressPubkeyConverter, integrationTests.TestTxSignMarshalizer, integrationTests.TestTxSignHasher)
 	tx.Signature, _ = relayer.SingleSigner.Sign(relayer.SkTxSign, txBuff)
 	relayer.Nonce++
-	txFee := economicsFee.ComputeTxFee(tx)
-	relayer.Balance.Sub(relayer.Balance, txFee)
+
 	relayer.Balance.Sub(relayer.Balance, tx.Value)
 
+	subFeesFromRelayer(tx, userTx, economicsFee, relayer)
+
 	return tx
 }
 
@@ -227,10 +230,11 @@ func createRelayedTxV3(
 	txBuff, _ := tx.GetDataForSigning(integrationTests.TestAddressPubkeyConverter, integrationTests.TestTxSignMarshalizer, integrationTests.TestTxSignHasher)
 	tx.Signature, _ = relayer.SingleSigner.Sign(relayer.SkTxSign, txBuff)
 	relayer.Nonce++
-	txFee := economicsFee.ComputeTxFee(tx)
-	relayer.Balance.Sub(relayer.Balance, txFee)
+
 	relayer.Balance.Sub(relayer.Balance, tx.Value)
 
+	subFeesFromRelayer(tx, userTx, economicsFee, relayer)
+
 	return tx
 }
 
@@ -286,3 +290,15 @@ func GetUserAccount(
 	}
 	return nil
 }
+
+func subFeesFromRelayer(tx, userTx *transaction.Transaction, economicsFee process.FeeHandler, relayer *integrationTests.TestWalletAccount) {
+	relayerFee := economicsFee.ComputeMoveBalanceFee(tx)
+	relayer.Balance.Sub(relayer.Balance, relayerFee)
+
+	userTxCopy := *userTx
+	if userTxCopy.GasLimit == 0 { // relayed v2
+		userTxCopy.GasLimit = tx.GasLimit - economicsFee.ComputeGasLimit(tx)
+	}
+	userFee := economicsFee.ComputeTxFee(&userTxCopy)
+	relayer.Balance.Sub(relayer.Balance, userFee)
+}

integrationTests/multiShard/relayedTx/edgecases/edgecases_test.go

@@ -6,8 +6,10 @@ import (
 	"time"
 
 	"github.com/multiversx/mx-chain-core-go/core/check"
+	"github.com/multiversx/mx-chain-core-go/data/transaction"
 	"github.com/multiversx/mx-chain-go/integrationTests"
 	"github.com/multiversx/mx-chain-go/integrationTests/multiShard/relayedTx"
+	"github.com/multiversx/mx-chain-go/process"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -38,12 +40,10 @@ func TestRelayedTransactionInMultiShardEnvironmentWithNormalTxButWrongNonceShoul
 	for i := int64(0); i < nrRoundsToTest; i++ {
 		for _, player := range players {
 			player.Nonce += 1
-			relayerTx := relayedTx.CreateAndSendRelayedAndUserTx(nodes, relayer, player, receiverAddress1, sendValue, integrationTests.MinTxGasLimit, []byte(""))
-			totalFee := nodes[0].EconomicsData.ComputeTxFee(relayerTx)
-			totalFees.Add(totalFees, totalFee)
-			relayerTx = relayedTx.CreateAndSendRelayedAndUserTx(nodes, relayer, player, receiverAddress2, sendValue, integrationTests.MinTxGasLimit, []byte(""))
-			totalFee = nodes[0].EconomicsData.ComputeTxFee(relayerTx)
-			totalFees.Add(totalFees, totalFee)
+			relayerTx, userTx := relayedTx.CreateAndSendRelayedAndUserTx(nodes, relayer, player, receiverAddress1, sendValue, integrationTests.MinTxGasLimit, []byte(""))
+			appendFeeToTotalFees(relayerTx, userTx, nodes[0].EconomicsData, totalFees)
+			relayerTx, userTx = relayedTx.CreateAndSendRelayedAndUserTx(nodes, relayer, player, receiverAddress2, sendValue, integrationTests.MinTxGasLimit, []byte(""))
+			appendFeeToTotalFees(relayerTx, userTx, nodes[0].EconomicsData, totalFees)
 		}
 
 		round, nonce = integrationTests.ProposeAndSyncOneBlock(t, nodes, idxProposers, round, nonce)
@@ -108,10 +108,8 @@ func TestRelayedTransactionInMultiShardEnvironmentWithNormalTxButWithTooMuchGas(
 
 	for i := int64(0); i < nrRoundsToTest; i++ {
 		for _, player := range players {
-			_ = relayedTx.CreateAndSendRelayedAndUserTx(nodes, relayer, player, receiverAddress1, sendValue, tooMuchGasLimit, []byte(""))
-			player.Balance.Sub(player.Balance, sendValue)
-			_ = relayedTx.CreateAndSendRelayedAndUserTx(nodes, relayer, player, receiverAddress2, sendValue, tooMuchGasLimit, []byte(""))
-			player.Balance.Sub(player.Balance, sendValue)
+			_, _ = relayedTx.CreateAndSendRelayedAndUserTx(nodes, relayer, player, receiverAddress1, sendValue, tooMuchGasLimit, []byte(""))
+			_, _ = relayedTx.CreateAndSendRelayedAndUserTx(nodes, relayer, player, receiverAddress2, sendValue, tooMuchGasLimit, []byte(""))
 		}
 
 		round, nonce = integrationTests.ProposeAndSyncOneBlock(t, nodes, idxProposers, round, nonce)
@@ -151,3 +149,15 @@ func checkPlayerBalancesWithPenalization(
 		assert.Equal(t, userAcc.GetNonce(), players[i].Nonce)
 	}
 }
+
+func appendFeeToTotalFees(relayerTx, userTx *transaction.Transaction, economicsData process.EconomicsDataHandler, totalFees *big.Int) {
+	relayerFee := economicsData.ComputeMoveBalanceFee(relayerTx)
+	totalFees.Add(totalFees, relayerFee)
+
+	userTxCopy := *userTx
+	if userTxCopy.GasLimit == 0 { // relayed v2
+		userTxCopy.GasLimit = relayerTx.GasLimit - economicsData.ComputeGasLimit(relayerTx)
+	}
+	userFee := economicsData.ComputeTxFee(&userTxCopy)
+	totalFees.Add(totalFees, userFee)
+}

integrationTests/multiShard/relayedTx/relayedTx_test.go

@@ -21,7 +21,15 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-type createAndSendRelayedAndUserTxFuncType = func([]*integrationTests.TestProcessorNode, *integrationTests.TestWalletAccount, *integrationTests.TestWalletAccount, []byte, *big.Int, uint64, []byte) *transaction.Transaction
+type createAndSendRelayedAndUserTxFuncType = func(
+	nodes []*integrationTests.TestProcessorNode,
+	relayer *integrationTests.TestWalletAccount,
+	player *integrationTests.TestWalletAccount,
+	rcvAddr []byte,
+	value *big.Int,
+	gasLimit uint64,
+	txData []byte,
+) (*transaction.Transaction, *transaction.Transaction)
 
 func TestRelayedTransactionInMultiShardEnvironmentWithNormalTx(t *testing.T) {
 	t.Run("relayed v1", testRelayedTransactionInMultiShardEnvironmentWithNormalTx(CreateAndSendRelayedAndUserTx))
@@ -78,10 +86,8 @@ func testRelayedTransactionInMultiShardEnvironmentWithNormalTx(
 
 		for i := int64(0); i < nrRoundsToTest; i++ {
 			for _, player := range players {
-				_ = createAndSendRelayedAndUserTxFunc(nodes, relayer, player, receiverAddress1, sendValue, integrationTests.MinTxGasLimit, []byte(""))
-				player.Balance.Sub(player.Balance, sendValue)
-				_ = createAndSendRelayedAndUserTxFunc(nodes, relayer, player, receiverAddress2, sendValue, integrationTests.MinTxGasLimit, []byte(""))
-				player.Balance.Sub(player.Balance, sendValue)
+				_, _ = createAndSendRelayedAndUserTxFunc(nodes, relayer, player, receiverAddress1, sendValue, integrationTests.MinTxGasLimit, []byte(""))
+				_, _ = createAndSendRelayedAndUserTxFunc(nodes, relayer, player, receiverAddress2, sendValue, integrationTests.MinTxGasLimit, []byte(""))
 			}
 
 			round, nonce = integrationTests.ProposeAndSyncOneBlock(t, nodes, idxProposers, round, nonce)
@@ -174,9 +180,9 @@ func testRelayedTransactionInMultiShardEnvironmentWithSmartContractTX(
 			integrationTests.AddSelfNotarizedHeaderByMetachain(nodes)
 
 			for _, player := range players {
-				_ = createAndSendRelayedAndUserTxFunc(nodes, relayer, player, scAddress, big.NewInt(0),
+				_, _ = createAndSendRelayedAndUserTxFunc(nodes, relayer, player, scAddress, big.NewInt(0),
 					transferTokenFullGas, []byte("transferToken@"+hex.EncodeToString(receiverAddress1)+"@00"+hex.EncodeToString(sendValue.Bytes())))
-				_ = createAndSendRelayedAndUserTxFunc(nodes, relayer, player, scAddress, big.NewInt(0),
+				_, _ = createAndSendRelayedAndUserTxFunc(nodes, relayer, player, scAddress, big.NewInt(0),
 					transferTokenFullGas, []byte("transferToken@"+hex.EncodeToString(receiverAddress2)+"@00"+hex.EncodeToString(sendValue.Bytes())))
 			}
 
@@ -273,8 +279,8 @@ func testRelayedTransactionInMultiShardEnvironmentWithESDTTX(
 		nrRoundsToTest := int64(5)
 		for i := int64(0); i < nrRoundsToTest; i++ {
 			for _, player := range players {
-				_ = createAndSendRelayedAndUserTxFunc(nodes, relayer, player, receiverAddress1, big.NewInt(0), transferTokenFullGas, []byte(txData))
-				_ = createAndSendRelayedAndUserTxFunc(nodes, relayer, player, receiverAddress2, big.NewInt(0), transferTokenFullGas, []byte(txData))
+				_, _ = createAndSendRelayedAndUserTxFunc(nodes, relayer, player, receiverAddress1, big.NewInt(0), transferTokenFullGas, []byte(txData))
+				_, _ = createAndSendRelayedAndUserTxFunc(nodes, relayer, player, receiverAddress2, big.NewInt(0), transferTokenFullGas, []byte(txData))
 			}
 
 			round, nonce = integrationTests.ProposeAndSyncOneBlock(t, nodes, idxProposers, round, nonce)
@@ -353,7 +359,7 @@ func testRelayedTransactionInMultiShardEnvironmentWithAttestationContract(
 		uniqueIDs := make([]string, len(players))
 		for i, player := range players {
 			uniqueIDs[i] = core.UniqueIdentifier()
-			_ = createAndSendRelayedAndUserTxFunc(nodes, relayer, player, scAddress, registerValue,
+			_, _ = createAndSendRelayedAndUserTxFunc(nodes, relayer, player, scAddress, registerValue,
 				registerVMGas, []byte("register@"+hex.EncodeToString([]byte(uniqueIDs[i]))))
 		}
 		time.Sleep(time.Second)
@@ -383,9 +389,9 @@ func testRelayedTransactionInMultiShardEnvironmentWithAttestationContract(
 		integrationTests.MintAllPlayers(nodes, players, registerValue)
 
 		for i, player := range players {
-			_ = createAndSendRelayedAndUserTxFunc(nodes, relayer, player, scAddress, big.NewInt(0), attestVMGas,
+			_, _ = createAndSendRelayedAndUserTxFunc(nodes, relayer, player, scAddress, big.NewInt(0), attestVMGas,
 				[]byte("attest@"+hex.EncodeToString([]byte(uniqueIDs[i]))+"@"+hex.EncodeToString([]byte(privateInfos[i]))))
-			_ = createAndSendRelayedAndUserTxFunc(nodes, relayer, player, scAddress, registerValue,
+			_, _ = createAndSendRelayedAndUserTxFunc(nodes, relayer, player, scAddress, registerValue,
 				registerVMGas, []byte("register@"+hex.EncodeToString([]byte(uniqueIDs[i]))))
 		}
 		time.Sleep(time.Second)

integrationTests/multiShard/smartContract/dns/dns_test.go

@@ -202,7 +202,7 @@ func sendRegisterUserNameAsRelayedTx(
 	for i, player := range players {
 		userName := generateNewUserName()
 		scAddress := selectDNSAddressFromUserName(sortedDNSAddresses, userName)
-		_ = relayedTx.CreateAndSendRelayedAndUserTx(nodes, relayer, player, []byte(scAddress), dnsRegisterValue,
+		_, _ = relayedTx.CreateAndSendRelayedAndUserTx(nodes, relayer, player, []byte(scAddress), dnsRegisterValue,
 			gasLimit, []byte("register@"+hex.EncodeToString([]byte(userName))))
 		userNames[i] = userName
 	}

integrationTests/testProcessorNode.go

@@ -3235,6 +3235,7 @@ func CreateEnableEpochsConfig() config.EnableEpochs {
 		RefactorPeersMiniBlocksEnableEpoch:                UnreachableEpoch,
 		SCProcessorV2EnableEpoch:                          UnreachableEpoch,
 		RelayedTransactionsV3EnableEpoch:                  UnreachableEpoch,
+		FixRelayedMoveBalanceEnableEpoch:                  UnreachableEpoch,
 	}
 }