rc/barnard

api/groups/blockGroup.go

@@ -26,6 +26,7 @@ const (
 	urlParamTokensFilter      = "tokens"
 	urlParamWithTxs           = "withTxs"
 	urlParamWithLogs          = "withLogs"
+	urlParamForHyperblock     = "forHyperblock"
 )
 
 // blockFacadeHandler defines the methods to be implemented by a facade for handling block requests
@@ -219,7 +220,12 @@ func parseBlockQueryOptions(c *gin.Context) (api.BlockQueryOptions, error) {
 		return api.BlockQueryOptions{}, err
 	}
 
-	options := api.BlockQueryOptions{WithTransactions: withTxs, WithLogs: withLogs}
+	forHyperBlock, err := parseBoolUrlParam(c, urlParamForHyperblock)
+	if err != nil {
+		return api.BlockQueryOptions{}, err
+	}
+
+	options := api.BlockQueryOptions{WithTransactions: withTxs, WithLogs: withLogs, ForHyperblock: forHyperBlock}
 	return options, nil
 }
 

api/groups/blockGroup_test.go

@@ -90,7 +90,7 @@ func TestBlockGroup_getBlockByNonce(t *testing.T) {
 		t.Parallel()
 
 		providedNonce := uint64(37)
-		expectedOptions := api.BlockQueryOptions{WithTransactions: true}
+		expectedOptions := api.BlockQueryOptions{WithTransactions: true, ForHyperblock: true}
 		expectedBlock := api.Block{
 			Nonce: 37,
 			Round: 39,
@@ -107,7 +107,7 @@ func TestBlockGroup_getBlockByNonce(t *testing.T) {
 		loadBlockGroupResponse(
 			t,
 			facade,
-			fmt.Sprintf("/block/by-nonce/%d?withTxs=true", providedNonce),
+			fmt.Sprintf("/block/by-nonce/%d?withTxs=true&forHyperblock=true", providedNonce),
 			"GET",
 			nil,
 			response,

api/groups/networkGroup_test.go

@@ -206,6 +206,36 @@ func TestNetworkConfigMetrics_GasLimitGuardedTxShouldWork(t *testing.T) {
 	assert.True(t, keyAndValueFoundInResponse)
 }
 
+func TestNetworkConfigMetrics_GasLimitRelayedTxShouldWork(t *testing.T) {
+	t.Parallel()
+
+	statusMetricsProvider := statusHandler.NewStatusMetrics()
+	key := common.MetricExtraGasLimitRelayedTx
+	val := uint64(123)
+	statusMetricsProvider.SetUInt64Value(key, val)
+
+	facade := mock.FacadeStub{}
+	facade.StatusMetricsHandler = func() external.StatusMetricsHandler {
+		return statusMetricsProvider
+	}
+
+	networkGroup, err := groups.NewNetworkGroup(&facade)
+	require.NoError(t, err)
+
+	ws := startWebServer(networkGroup, "network", getNetworkRoutesConfig())
+
+	req, _ := http.NewRequest("GET", "/network/config", nil)
+	resp := httptest.NewRecorder()
+	ws.ServeHTTP(resp, req)
+
+	respBytes, _ := io.ReadAll(resp.Body)
+	respStr := string(respBytes)
+	assert.Equal(t, resp.Code, http.StatusOK)
+
+	keyAndValueFoundInResponse := strings.Contains(respStr, key) && strings.Contains(respStr, fmt.Sprintf("%d", val))
+	assert.True(t, keyAndValueFoundInResponse)
+}
+
 func TestNetworkStatusMetrics_ShouldWork(t *testing.T) {
 	t.Parallel()
 

api/groups/transactionGroup.go

@@ -720,21 +720,23 @@ func (tg *transactionGroup) getTransactionsPoolNonceGapsForSender(sender string,
 
 func (tg *transactionGroup) createTransaction(receivedTx *transaction.FrontendTransaction) (*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,
+		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.RelayerAddr,
+		RelayerSignatureHex: receivedTx.RelayerSignature,
 	}
 	start := time.Now()
 	tx, txHash, err := tg.getFacade().CreateTransaction(txArgs)

cmd/node/config/economics.toml

@@ -39,9 +39,10 @@
 
 [FeeSettings]
     GasLimitSettings = [
-        {EnableEpoch = 0, MaxGasLimitPerBlock = "1500000000", MaxGasLimitPerMiniBlock = "1500000000", MaxGasLimitPerMetaBlock = "15000000000", MaxGasLimitPerMetaMiniBlock = "15000000000", MaxGasLimitPerTx = "1500000000", MinGasLimit = "50000", ExtraGasLimitGuardedTx  = "50000"},
-        {EnableEpoch = 1, MaxGasLimitPerBlock = "1500000000", MaxGasLimitPerMiniBlock = "250000000", MaxGasLimitPerMetaBlock = "15000000000", MaxGasLimitPerMetaMiniBlock = "250000000", MaxGasLimitPerTx = "600000000", MinGasLimit = "50000", ExtraGasLimitGuardedTx  = "50000"},
-        {EnableEpoch = 2, MaxGasLimitPerBlock = "1500000000", MaxGasLimitPerMiniBlock = "250000000", MaxGasLimitPerMetaBlock = "15000000000", MaxGasLimitPerMetaMiniBlock = "250000000", MaxGasLimitPerTx = "600000000", MinGasLimit = "50000", ExtraGasLimitGuardedTx  = "50000"},
+        {EnableEpoch = 0, MaxGasLimitPerBlock = "1500000000", MaxGasLimitPerMiniBlock = "1500000000", MaxGasLimitPerMetaBlock = "15000000000", MaxGasLimitPerMetaMiniBlock = "15000000000", MaxGasLimitPerTx = "1500000000", MinGasLimit = "50000", ExtraGasLimitGuardedTx  = "50000", MaxGasHigherFactorAccepted = "10"},
+        {EnableEpoch = 1, MaxGasLimitPerBlock = "1500000000", MaxGasLimitPerMiniBlock = "250000000", MaxGasLimitPerMetaBlock = "15000000000", MaxGasLimitPerMetaMiniBlock = "250000000", MaxGasLimitPerTx = "600000000", MinGasLimit = "50000", ExtraGasLimitGuardedTx  = "50000", MaxGasHigherFactorAccepted = "10"},
+        {EnableEpoch = 2, MaxGasLimitPerBlock = "1500000000", MaxGasLimitPerMiniBlock = "250000000", MaxGasLimitPerMetaBlock = "15000000000", MaxGasLimitPerMetaMiniBlock = "250000000", MaxGasLimitPerTx = "600000000", MinGasLimit = "50000", ExtraGasLimitGuardedTx  = "50000", MaxGasHigherFactorAccepted = "10"},
+        {EnableEpoch = 3, MaxGasLimitPerBlock = "1500000000", MaxGasLimitPerMiniBlock = "250000000", MaxGasLimitPerMetaBlock = "15000000000", MaxGasLimitPerMetaMiniBlock = "250000000", MaxGasLimitPerTx = "600000000", MinGasLimit = "50000", ExtraGasLimitGuardedTx  = "50000", MaxGasHigherFactorAccepted = "2"},
     ]
     MinGasPrice             = "1000000000" #will yield min tx fee of 0.00005 eGLD
     GasPriceModifier        = 0.01

cmd/node/config/enableEpochs.toml

@@ -333,6 +333,9 @@
     # FixRelayedMoveBalanceToNonPayableSCEnableEpoch represents the epoch when the fix for relayed move balance to non payable sc will be enabled
     FixRelayedMoveBalanceToNonPayableSCEnableEpoch = 1
 
+    # RelayedTransactionsV3EnableEpoch represents the epoch when the relayed transactions v3 will be enabled
+    RelayedTransactionsV3EnableEpoch = 2
+
     # BLSMultiSignerEnableEpoch represents the activation epoch for different types of BLS multi-signers
     BLSMultiSignerEnableEpoch = [
         { EnableEpoch = 0, Type = "no-KOSK" },

cmd/node/config/external.toml

@@ -12,8 +12,8 @@
     Username          = ""
     Password          = ""
     # EnabledIndexes represents a slice of indexes that will be enabled for indexing. Full list is:
-    # ["rating", "transactions", "blocks", "validators", "miniblocks", "rounds", "accounts", "accountshistory", "receipts", "scresults", "accountsesdt", "accountsesdthistory", "epochinfo", "scdeploys", "tokens", "tags", "logs", "delegators", "operations", "esdts"]
-    EnabledIndexes    = ["rating", "transactions", "blocks", "validators", "miniblocks", "rounds", "accounts", "accountshistory", "receipts", "scresults", "accountsesdt", "accountsesdthistory", "epochinfo", "scdeploys", "tokens", "tags", "logs", "delegators", "operations", "esdts"]
+    # ["rating", "transactions", "blocks", "validators", "miniblocks", "rounds", "accounts", "accountshistory", "receipts", "scresults", "accountsesdt", "accountsesdthistory", "epochinfo", "scdeploys", "tokens", "tags", "logs", "delegators", "operations", "esdts", "events"]
+    EnabledIndexes    = ["rating", "transactions", "blocks", "validators", "miniblocks", "rounds", "accounts", "accountshistory", "receipts", "scresults", "accountsesdt", "accountsesdthistory", "epochinfo", "scdeploys", "tokens", "tags", "logs", "delegators", "operations", "esdts", "events"]
 
 # EventNotifierConnector defines settings needed to configure and launch the event notifier component
 # HTTP event notifier connector integration will be DEPRECATED in the following iterations

common/common.go

@@ -0,0 +1,26 @@
+package common
+
+import "github.com/multiversx/mx-chain-core-go/data"
+
+// IsValidRelayedTxV3 returns true if the provided transaction is a valid transaction of type relayed v3
+func IsValidRelayedTxV3(tx data.TransactionHandler) bool {
+	relayedTx, isRelayedV3 := tx.(data.RelayedTransactionHandler)
+	if !isRelayedV3 {
+		return false
+	}
+	hasValidRelayer := len(relayedTx.GetRelayerAddr()) == len(tx.GetSndAddr()) && len(relayedTx.GetRelayerAddr()) > 0
+	hasValidRelayerSignature := len(relayedTx.GetRelayerSignature()) == len(relayedTx.GetSignature()) && len(relayedTx.GetRelayerSignature()) > 0
+	return hasValidRelayer && hasValidRelayerSignature
+}
+
+// IsRelayedTxV3 returns true if the provided transaction is a transaction of type relayed v3, without any further checks
+func IsRelayedTxV3(tx data.TransactionHandler) bool {
+	relayedTx, isRelayedV3 := tx.(data.RelayedTransactionHandler)
+	if !isRelayedV3 {
+		return false
+	}
+
+	hasRelayer := len(relayedTx.GetRelayerAddr()) > 0
+	hasRelayerSignature := len(relayedTx.GetRelayerSignature()) > 0
+	return hasRelayer || hasRelayerSignature
+}

common/common_test.go

@@ -0,0 +1,70 @@
+package common
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/multiversx/mx-chain-core-go/data/smartContractResult"
+	"github.com/multiversx/mx-chain-core-go/data/transaction"
+	"github.com/stretchr/testify/require"
+)
+
+func TestIsValidRelayedTxV3(t *testing.T) {
+	t.Parallel()
+
+	scr := &smartContractResult.SmartContractResult{}
+	require.False(t, IsValidRelayedTxV3(scr))
+	require.False(t, IsRelayedTxV3(scr))
+
+	notRelayedTxV3 := &transaction.Transaction{
+		Nonce:     1,
+		Value:     big.NewInt(100),
+		RcvAddr:   []byte("receiver"),
+		SndAddr:   []byte("sender0"),
+		GasPrice:  100,
+		GasLimit:  10,
+		Signature: []byte("signature"),
+	}
+	require.False(t, IsValidRelayedTxV3(notRelayedTxV3))
+	require.False(t, IsRelayedTxV3(notRelayedTxV3))
+
+	invalidRelayedTxV3 := &transaction.Transaction{
+		Nonce:       1,
+		Value:       big.NewInt(100),
+		RcvAddr:     []byte("receiver"),
+		SndAddr:     []byte("sender0"),
+		GasPrice:    100,
+		GasLimit:    10,
+		Signature:   []byte("signature"),
+		RelayerAddr: []byte("relayer"),
+	}
+	require.False(t, IsValidRelayedTxV3(invalidRelayedTxV3))
+	require.True(t, IsRelayedTxV3(invalidRelayedTxV3))
+
+	invalidRelayedTxV3 = &transaction.Transaction{
+		Nonce:            1,
+		Value:            big.NewInt(100),
+		RcvAddr:          []byte("receiver"),
+		SndAddr:          []byte("sender0"),
+		GasPrice:         100,
+		GasLimit:         10,
+		Signature:        []byte("signature"),
+		RelayerSignature: []byte("signature"),
+	}
+	require.False(t, IsValidRelayedTxV3(invalidRelayedTxV3))
+	require.True(t, IsRelayedTxV3(invalidRelayedTxV3))
+
+	relayedTxV3 := &transaction.Transaction{
+		Nonce:            1,
+		Value:            big.NewInt(100),
+		RcvAddr:          []byte("receiver"),
+		SndAddr:          []byte("sender1"),
+		GasPrice:         100,
+		GasLimit:         10,
+		Signature:        []byte("signature"),
+		RelayerAddr:      []byte("relayer"),
+		RelayerSignature: []byte("signature"),
+	}
+	require.True(t, IsValidRelayedTxV3(relayedTxV3))
+	require.True(t, IsRelayedTxV3(relayedTxV3))
+}

common/constants.go

@@ -340,6 +340,9 @@ const MetricMinGasLimit = "erd_min_gas_limit"
 // MetricExtraGasLimitGuardedTx specifies the extra gas limit required for guarded transactions
 const MetricExtraGasLimitGuardedTx = "erd_extra_gas_limit_guarded_tx"
 
+// MetricExtraGasLimitRelayedTx specifies the extra gas limit required for relayed v3 transactions
+const MetricExtraGasLimitRelayedTx = "erd_extra_gas_limit_relayed_tx"
+
 // MetricRewardsTopUpGradientPoint is the metric that specifies the rewards top up gradient point
 const MetricRewardsTopUpGradientPoint = "erd_rewards_top_up_gradient_point"
 
@@ -737,6 +740,9 @@ const (
 	// MetricFixRelayedMoveBalanceToNonPayableSCEnableEpoch represents the epoch when the fix for relayed move balance to non-payable sc is enabled
 	MetricFixRelayedMoveBalanceToNonPayableSCEnableEpoch = "erd_fix_relayed_move_balance_to_non_payable_sc_enable_epoch"
 
+	// MetricRelayedTransactionsV3EnableEpoch represents the epoch when the relayed transactions v3 are enabled
+	MetricRelayedTransactionsV3EnableEpoch = "erd_relayed_transactions_v3_enable_epoch"
+
 	// MetricMaxNodesChangeEnableEpoch holds configuration for changing the maximum number of nodes and the enabling epoch
 	MetricMaxNodesChangeEnableEpoch = "erd_max_nodes_change_enable_epoch"
 
@@ -1234,5 +1240,6 @@ const (
 	FixRelayedBaseCostFlag                             core.EnableEpochFlag = "FixRelayedBaseCostFlag"
 	MultiESDTNFTTransferAndExecuteByUserFlag           core.EnableEpochFlag = "MultiESDTNFTTransferAndExecuteByUserFlag"
 	FixRelayedMoveBalanceToNonPayableSCFlag            core.EnableEpochFlag = "FixRelayedMoveBalanceToNonPayableSCFlag"
+	RelayedTransactionsV3Flag                          core.EnableEpochFlag = "RelayedTransactionsV3Flag"
 	// all new flags must be added to createAllFlagsMap method, as part of enableEpochsHandler allFlagsDefined
 )

common/enablers/enableEpochsHandler.go

@@ -780,6 +780,12 @@ func (handler *enableEpochsHandler) createAllFlagsMap() {
 			},
 			activationEpoch: handler.enableEpochsConfig.FixRelayedMoveBalanceToNonPayableSCEnableEpoch,
 		},
+		common.RelayedTransactionsV3Flag: {
+			isActiveInEpoch: func(epoch uint32) bool {
+				return epoch >= handler.enableEpochsConfig.RelayedTransactionsV3EnableEpoch
+			},
+			activationEpoch: handler.enableEpochsConfig.RelayedTransactionsV3EnableEpoch,
+		},
 	}
 }
 

common/enablers/enableEpochsHandler_test.go

@@ -123,6 +123,7 @@ func createEnableEpochsConfig() config.EnableEpochs {
 		MultiESDTNFTTransferAndExecuteByUserEnableEpoch:          106,
 		FixRelayedMoveBalanceToNonPayableSCEnableEpoch:           107,
 		UseGasBoundedShouldFailExecutionEnableEpoch:              108,
+		RelayedTransactionsV3EnableEpoch:                         109,
 	}
 }
 
@@ -448,6 +449,7 @@ func TestEnableEpochsHandler_GetActivationEpoch(t *testing.T) {
 	require.Equal(t, cfg.FixRelayedBaseCostEnableEpoch, handler.GetActivationEpoch(common.FixRelayedBaseCostFlag))
 	require.Equal(t, cfg.MultiESDTNFTTransferAndExecuteByUserEnableEpoch, handler.GetActivationEpoch(common.MultiESDTNFTTransferAndExecuteByUserFlag))
 	require.Equal(t, cfg.FixRelayedMoveBalanceToNonPayableSCEnableEpoch, handler.GetActivationEpoch(common.FixRelayedMoveBalanceToNonPayableSCFlag))
+	require.Equal(t, cfg.RelayedTransactionsV3EnableEpoch, handler.GetActivationEpoch(common.RelayedTransactionsV3Flag))
 }
 
 func TestEnableEpochsHandler_IsInterfaceNil(t *testing.T) {

common/reflectcommon/structFieldsUpdate.go

@@ -126,7 +126,7 @@ func trySetTheNewValue(value *reflect.Value, newValue interface{}) error {
 	case reflect.Map:
 		mapValue := reflect.ValueOf(newValue)
 
-		return tryUpdateMapValue(value, mapValue)
+		return trySetMapValue(value, mapValue)
 	default:
 		return fmt.Errorf("unsupported type <%s> when trying to set the value '%v' of type <%s>", valueKind, newValue, reflect.TypeOf(newValue))
 	}
@@ -141,7 +141,7 @@ func trySetSliceValue(value *reflect.Value, newValue interface{}) error {
 		item := sliceVal.Index(i)
 		newItem := reflect.New(value.Type().Elem()).Elem()
 
-		err := trySetStructValue(&newItem, item)
+		err := trySetTheNewValue(&newItem, item.Interface())
 		if err != nil {
 			return err
 		}
@@ -167,7 +167,7 @@ func trySetStructValue(value *reflect.Value, newValue reflect.Value) error {
 	}
 }
 
-func tryUpdateMapValue(value *reflect.Value, newValue reflect.Value) error {
+func trySetMapValue(value *reflect.Value, newValue reflect.Value) error {
 	if value.IsNil() {
 		value.Set(reflect.MakeMap(value.Type()))
 	}