Sf 1.11.0

cmd/node/flags.go

@@ -230,7 +230,7 @@ var (
 	allValidatorKeysPemFile = cli.StringFlag{
 		Name:  "all-validator-keys-pem-file",
 		Usage: "The `filepath` for the PEM file which contains all the secret keys managed by the current node.",
-		Value: "./config/allValidatorsKeys.pem",
+		Value: "./config/allValidatorsKeysSF.pem",
 	}
 
 	// logLevel defines the logger level

cmd/node/main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"os"
+	"path/filepath"
 	"runtime"
 	"time"
 
@@ -82,13 +83,43 @@ func main() {
 		return startNodeRunner(c, log, baseVersion, app.Version)
 	}
 
+	// TODO: remove this after the first release
+	renameDB()
+
 	err := app.Run(os.Args)
 	if err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
 	}
 }
 
+func renameDB() {
+	// Define source and destination paths
+	sourcePath := filepath.Join("db", "1")
+	destPath := filepath.Join("db", "B")
+
+	// Check if source directory exists
+	if _, err := os.Stat(sourcePath); os.IsNotExist(err) {
+		fmt.Printf("Error: Source directory '%s' does not exist\n", sourcePath)
+		//os.Exit(1)
+	}
+
+	// Check if destination already exists
+	if _, err := os.Stat(destPath); err == nil {
+		fmt.Printf("Error: Destination directory '%s' already exists\n", destPath)
+		//os.Exit(1)
+	}
+
+	// Rename the directory
+	err := os.Rename(sourcePath, destPath)
+	if err != nil {
+		fmt.Printf("Error renaming directory: %v\n", err)
+		//os.Exit(1)
+	}
+
+	fmt.Printf("Successfully renamed '%s' to '%s'\n", sourcePath, destPath)
+}
+
 func startNodeRunner(c *cli.Context, log logger.Logger, baseVersion string, version string) error {
 	flagsConfig := getFlagsConfig(c, log)
 

common/constants.go

@@ -64,7 +64,7 @@ const DisabledShardIDAsObserver = uint32(0xFFFFFFFF) - 7
 
 // MaxTxNonceDeltaAllowed specifies the maximum difference between an account's nonce and a received transaction's nonce
 // in order to mark the transaction as valid.
-const MaxTxNonceDeltaAllowed = 100
+const MaxTxNonceDeltaAllowed = 100000
 
 // MaxBulkTransactionSize specifies the maximum size of one bulk with txs which can be send over the network
 // TODO convert this const into a var and read it from config when this code moves to another binary

consensus/spos/bls/constants.go

@@ -33,6 +33,36 @@
 	MtInvalidSigners
 )
 
+// waitingAllSigsMaxTimeThreshold specifies the max allocated time for waiting all signatures from the total time of the subround signature
+const waitingAllSigsMaxTimeThreshold = 0.5
+
+// processingThresholdPercent specifies the max allocated time for processing the block as a percentage of the total time of the round
+const processingThresholdPercent = 85
+
+// srStartStartTime specifies the start time, from the total time of the round, of Subround Start
+const srStartStartTime = 0.0
+
+// srEndStartTime specifies the end time, from the total time of the round, of Subround Start
+const srStartEndTime = 0.05
+
+// srBlockStartTime specifies the start time, from the total time of the round, of Subround Block
+const srBlockStartTime = 0.05
+
+// srBlockEndTime specifies the end time, from the total time of the round, of Subround Block
+const srBlockEndTime = 0.45
+
+// srSignatureStartTime specifies the start time, from the total time of the round, of Subround Signature
+const srSignatureStartTime = 0.45
+
+// srSignatureEndTime specifies the end time, from the total time of the round, of Subround Signature
+const srSignatureEndTime = 0.85
+
+// srEndStartTime specifies the start time, from the total time of the round, of Subround End
+const srEndStartTime = 0.85
+
+// srEndEndTime specifies the end time, from the total time of the round, of Subround End
+const srEndEndTime = 0.95
+
 const (
 	// BlockBodyAndHeaderStringValue represents the string to be used to identify a block body and a block header
 	BlockBodyAndHeaderStringValue = "(BLOCK_BODY_AND_HEADER)"

consensus/spos/consensusMessageValidator.go

@@ -144,12 +144,6 @@ func (cmv *consensusMessageValidator) checkConsensusMessageValidity(cnsMsg *cons
 			len(cnsMsg.PubKey))
 	}
 
-	if len(cnsMsg.Signature) != cmv.signatureSize {
-		return fmt.Errorf("%w : received signature from consensus topic has an invalid size: %d",
-			ErrInvalidSignatureSize,
-			len(cnsMsg.Signature))
-	}
-
 	isNodeInEligibleList := cmv.consensusState.IsNodeInEligibleList(string(cnsMsg.PubKey))
 	if !isNodeInEligibleList {
 		return fmt.Errorf("%w : received message from consensus topic has an invalid public key: %s",
@@ -404,11 +398,11 @@ func (cmv *consensusMessageValidator) checkMessageWithSignatureValidity(cnsMsg *
 			logger.DisplayByteSlice(cnsMsg.PubKey))
 	}
 
-	if len(cnsMsg.SignatureShare) != cmv.signatureSize {
-		return fmt.Errorf("%w : received signature share from consensus topic has an invalid size: %d",
-			ErrInvalidSignatureSize,
-			len(cnsMsg.SignatureShare))
-	}
+	//if len(cnsMsg.SignatureShare) != cmv.signatureSize {
+	//	return fmt.Errorf("%w : received signature share from consensus topic has an invalid size: %d",
+	//		ErrInvalidSignatureSize,
+	//		len(cnsMsg.SignatureShare))
+	//}
 
 	return nil
 }
@@ -437,23 +431,6 @@ func (cmv *consensusMessageValidator) checkMessageWithFinalInfoValidity(cnsMsg *
 			len(cnsMsg.PubKeysBitmap))
 	}
 
-	if len(cnsMsg.AggregateSignature) != cmv.signatureSize {
-		return fmt.Errorf("%w : received aggregate signature from consensus topic has an invalid size: %d",
-			ErrInvalidSignatureSize,
-			len(cnsMsg.AggregateSignature))
-	}
-
-	// TODO[cleanup cns finality]: remove this
-	if cmv.shouldNotVerifyLeaderSignature() {
-		return nil
-	}
-
-	if len(cnsMsg.LeaderSignature) != cmv.signatureSize {
-		return fmt.Errorf("%w : received leader signature from consensus topic has an invalid size: %d",
-			ErrInvalidSignatureSize,
-			len(cnsMsg.LeaderSignature))
-	}
-
 	return nil
 }
 

factory/crypto/cryptoComponents.go

@@ -12,7 +12,6 @@ import (
 	disabledCrypto "github.com/multiversx/mx-chain-crypto-go/signing/disabled"
 	disabledSig "github.com/multiversx/mx-chain-crypto-go/signing/disabled/singlesig"
 	"github.com/multiversx/mx-chain-crypto-go/signing/ed25519"
-	"github.com/multiversx/mx-chain-crypto-go/signing/ed25519/singlesig"
 	"github.com/multiversx/mx-chain-crypto-go/signing/mcl"
 	mclSig "github.com/multiversx/mx-chain-crypto-go/signing/mcl/singlesig"
 	"github.com/multiversx/mx-chain-crypto-go/signing/secp256k1"
@@ -153,20 +152,21 @@ func (ccf *cryptoComponentsFactory) Create() (*cryptoComponents, error) {
 	}
 
 	txSignKeyGen := signing.NewKeyGenerator(ed25519.NewEd25519())
-	txSingleSigner := &singlesig.Ed25519Signer{}
-	processingSingleSigner, err := ccf.createSingleSigner(false)
+	txSingleSigner := &disabledSig.DisabledSingleSig{}
+
+	processingSingleSigner, err := ccf.createSingleSigner(true)
 	if err != nil {
 		return nil, err
 	}
 
-	interceptSingleSigner, err := ccf.createSingleSigner(ccf.importModeNoSigCheck)
+	interceptSingleSigner, err := ccf.createSingleSigner(true)
 	if err != nil {
 		return nil, err
 	}
 
 	p2pSingleSigner := &secp256k1SinglerSig.Secp256k1Signer{}
 
-	multiSigner, err := ccf.createMultiSignerContainer(blockSignKeyGen, ccf.importModeNoSigCheck)
+	multiSigner, err := ccf.createMultiSignerContainer(blockSignKeyGen, true)
 	if err != nil {
 		return nil, err
 	}
@@ -492,36 +492,12 @@ func (ccf *cryptoComponentsFactory) processAllHandledKeys(keygen crypto.KeyGener
 	return handledPrivateKeys, nil
 }
 
-func (ccf *cryptoComponentsFactory) processPrivatePublicKey(keygen crypto.KeyGenerator, encodedSk []byte, pkString string, index int) ([]byte, error) {
+func (ccf *cryptoComponentsFactory) processPrivatePublicKey(_ crypto.KeyGenerator, encodedSk []byte, _ string, index int) ([]byte, error) {
 	skBytes, err := hex.DecodeString(string(encodedSk))
 	if err != nil {
 		return nil, fmt.Errorf("%w for encoded secret key, key index %d", err, index)
 	}
 
-	pkBytes, err := ccf.validatorPubKeyConverter.Decode(pkString)
-	if err != nil {
-		return nil, fmt.Errorf("%w for encoded public key %s, key index %d", err, pkString, index)
-	}
-
-	sk, err := keygen.PrivateKeyFromByteArray(skBytes)
-	if err != nil {
-		return nil, fmt.Errorf("%w secret key, key index %d", err, index)
-	}
-
-	pk := sk.GeneratePublic()
-	pkGeneratedBytes, err := pk.ToByteArray()
-	if err != nil {
-		return nil, fmt.Errorf("%w while generating public key bytes, key index %d", err, index)
-	}
-
-	if !bytes.Equal(pkGeneratedBytes, pkBytes) {
-		return nil, fmt.Errorf("public keys mismatch, read %s, generated %s, key index %d",
-			pkString,
-			ccf.validatorPubKeyConverter.SilentEncode(pkBytes, log),
-			index,
-		)
-	}
-
 	return skBytes, nil
 }
 

factory/peerSignatureHandler/peerSignatureHandler.go

@@ -49,6 +49,9 @@ func NewPeerSignatureHandler(
 // VerifyPeerSignature verifies the signature associated with the public key. It first checks the cache for the public key,
 // and if it is not present, it will recompute the signature.
 func (psh *peerSignatureHandler) VerifyPeerSignature(pk []byte, pid core.PeerID, signature []byte) error {
+	if true {
+		return nil
+	}
 	if len(pk) == 0 {
 		return crypto.ErrInvalidPublicKey
 	}

keysManagement/managedPeersHolder.go

@@ -135,15 +135,24 @@ func generateNodeName(providedNodeName string, index int) string {
 // It errors if the generated public key is already contained by the struct
 // It will auto-generate some fields like the machineID and pid
 func (holder *managedPeersHolder) AddManagedPeer(privateKeyBytes []byte) error {
-	privateKey, err := holder.keyGenerator.PrivateKeyFromByteArray(privateKeyBytes)
-	if err != nil {
-		return fmt.Errorf("%w for provided bytes %s", err, hex.EncodeToString(privateKeyBytes))
-	}
+	var publicKeyBytes []byte
+	var privateKey crypto.PrivateKey
+	var err error
+	actualPrivateKey := len(privateKeyBytes) == 32
+	if actualPrivateKey {
+		privateKey, err = holder.keyGenerator.PrivateKeyFromByteArray(privateKeyBytes)
+		if err != nil {
+			return fmt.Errorf("%w for provided bytes %s", err, hex.EncodeToString(privateKeyBytes))
+		}
 
-	publicKey := privateKey.GeneratePublic()
-	publicKeyBytes, err := publicKey.ToByteArray()
-	if err != nil {
-		return fmt.Errorf("%w for provided bytes %s", err, hex.EncodeToString(privateKeyBytes))
+		publicKey := privateKey.GeneratePublic()
+		publicKeyBytes, err = publicKey.ToByteArray()
+		if err != nil {
+			return fmt.Errorf("%w for provided bytes %s", err, hex.EncodeToString(privateKeyBytes))
+		}
+	} else {
+		publicKeyBytes = privateKeyBytes
+		privateKey, _ = holder.keyGenerator.GeneratePair()
 	}
 
 	p2pPrivateKey, p2pPublicKey := holder.p2pKeyGenerator.GeneratePair()

node/external/transactionAPI/apiTransactionProcessor.go

@@ -343,16 +343,16 @@ func (atp *apiTransactionProcessor) getRegularTransactionsFromPool(requestedFiel
 func (atp *apiTransactionProcessor) getRewardTransactionsFromPool(requestedFieldsHandler fieldsHandler) ([]common.Transaction, error) {
 	rewardTxKeys := atp.dataPool.RewardTransactions().Keys()
 	rewardTxs := make([]common.Transaction, len(rewardTxKeys))
-	for idx, key := range rewardTxKeys {
-		txObj, found := atp.getRewardTxObjFromDataPool(key)
-		if !found {
-			continue
-		}
-
-		tx := atp.extractRequestedTxInfoFromObj(txObj, transaction.TxTypeReward, key, requestedFieldsHandler)
-
-		rewardTxs[idx] = tx
-	}
+	//for idx, key := range rewardTxKeys {
+	//	txObj, found := atp.getRewardTxObjFromDataPool(key)
+	//	if !found {
+	//		continue
+	//	}
+	//
+	//	tx := atp.extractRequestedTxInfoFromObj(txObj, transaction.TxTypeReward, key, requestedFieldsHandler)
+	//
+	//	rewardTxs[idx] = tx
+	//}
 
 	return rewardTxs, nil
 }

node/node.go

@@ -762,7 +762,7 @@ func (n *Node) ValidateTransaction(tx *transaction.Transaction) error {
 		return err
 	}
 
-	txValidator, intTx, err := n.commonTransactionValidation(tx, n.processComponents.WhiteListerVerifiedTxs(), n.processComponents.WhiteListHandler(), true)
+	txValidator, intTx, err := n.commonTransactionValidation(tx, n.processComponents.WhiteListerVerifiedTxs(), n.processComponents.WhiteListHandler(), false)
 	if err != nil {
 		return err
 	}

process/block/headerValidator.go

@@ -85,15 +85,6 @@ func (h *headerValidator) IsHeaderConstructionValid(currHeader, prevHeader data.
 		return process.ErrBlockHashDoesNotMatch
 	}
 
-	if !bytes.Equal(currHeader.GetPrevRandSeed(), prevHeader.GetRandSeed()) {
-		log.Trace("header random seed does not match",
-			"shard", currHeader.GetShardID(),
-			"local header random seed", prevHeader.GetRandSeed(),
-			"received header with prev random seed", currHeader.GetPrevRandSeed(),
-		)
-		return process.ErrRandSeedDoesNotMatch
-	}
-
 	return nil
 }