Merge branch 'master' into test_sc_epoch_0

Author: sstanculeanu

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.go

@@ -117,7 +117,7 @@ func NewNetworkGroup(facade networkFacadeHandler) (*networkGroup, error) {
 		{
 			Path:    getNFTsPath,
 			Method:  http.MethodGet,
-			Handler: ng.getHandlerFuncForEsdt(core.NonFungibleESDT),
+			Handler: ng.getHandlerFuncForEsdt(core.NonFungibleESDTv2),
 		},
 		{
 			Path:    directStakedInfoPath,

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/config.toml

@@ -386,9 +386,9 @@
 [TxDataPool]
     Name = "TxDataPool"
     Capacity = 600000
-    SizePerSender = 20000
+    SizePerSender = 5001
     SizeInBytes = 419430400 #400MB
-    SizeInBytesPerSender = 12288000
+    SizeInBytesPerSender = 12288000 #12MB
     Type = "TxCache"
     Shards = 16
 

cmd/node/config/enableEpochs.toml

@@ -313,25 +313,28 @@
     UseGasBoundedShouldFailExecutionEnableEpoch = 1
 
     # DynamicESDTEnableEpoch represents the epoch when dynamic NFT feature is enabled
-    DynamicESDTEnableEpoch = 4
+    DynamicESDTEnableEpoch = 1
 
     # EGLDInMultiTransferEnableEpoch represents the epoch when EGLD in multitransfer is enabled
-    EGLDInMultiTransferEnableEpoch = 4
+    EGLDInMultiTransferEnableEpoch = 1
 
     # CryptoOpcodesV2EnableEpoch represents the epoch when BLSMultiSig, Secp256r1 and other opcodes are enabled
-    CryptoOpcodesV2EnableEpoch = 4
+    CryptoOpcodesV2EnableEpoch = 1
 
     # UnjailCleanupEnableEpoch represents the epoch when the cleanup of the unjailed nodes is enabled
-    UnJailCleanupEnableEpoch = 4
+    UnJailCleanupEnableEpoch = 1
 
     # FixRelayedBaseCostEnableEpoch represents the epoch when the fix for relayed base cost will be enabled
-    FixRelayedBaseCostEnableEpoch = 4
+    FixRelayedBaseCostEnableEpoch = 1
 
     # MultiESDTNFTTransferAndExecuteByUserEnableEpoch represents the epoch when enshrined sovereign cross chain opcodes are enabled
     MultiESDTNFTTransferAndExecuteByUserEnableEpoch = 9999999
 
     # FixRelayedMoveBalanceToNonPayableSCEnableEpoch represents the epoch when the fix for relayed move balance to non payable sc will be enabled
-    FixRelayedMoveBalanceToNonPayableSCEnableEpoch = 4
+    FixRelayedMoveBalanceToNonPayableSCEnableEpoch = 1
+
+    # RelayedTransactionsV3EnableEpoch represents the epoch when the relayed transactions v3 will be enabled
+    RelayedTransactionsV3EnableEpoch = 1
 
     # BLSMultiSignerEnableEpoch represents the activation epoch for different types of BLS multi-signers
     BLSMultiSignerEnableEpoch = [

cmd/node/main.go

@@ -290,6 +290,7 @@ func attachFileLogger(log logger.Logger, flagsConfig *config.ContextFlagsConfig)
 	logger.ToggleCorrelation(flagsConfig.EnableLogCorrelation)
 	logger.ToggleLoggerName(flagsConfig.EnableLogName)
 	logLevelFlagValue := flagsConfig.LogLevel
+
 	err = logger.SetLogLevel(logLevelFlagValue)
 	if err != nil {
 		return nil, err

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))
+}