Metachain notarizez based on equivalent proofs #6513

sstanculeanu · 2024-10-02T16:03:04Z

Reasoning behind the pull request

metachain should notarize based on equivalent proofs

Proposed changes

update processors

Testing procedure

with feat branch

Pre-requisites

Based on the Contributing Guidelines the PR author and the reviewers must check the following requirements are met:

was the PR targeted to the correct branch?
if this is a larger feature that probably needs more than one PR, is there a feat branch created?
if this is a feat branch merging, do all satellite projects have a proper tag inside go.mod?

AdoAdoAdo · 2024-10-04T11:03:05Z

process/block/baseProcess.go

@@ -639,7 +642,7 @@ func (bp *baseProcessor) sortHeaderHashesForCurrentBlockByNonce(usedInBlock bool

 	bp.hdrsForCurrBlock.mutHdrsForBlock.RLock()
 	for metaBlockHash, headerInfo := range bp.hdrsForCurrBlock.hdrHashAndInfo {
-		if headerInfo.usedInBlock != usedInBlock {
+		if headerInfo.usedInBlock != usedInBlock || !headerInfo.hasProof {


I think that if a header is used in block but has no valid proof, then this is an error case
Could you add the condition separately and log an error for that?
in case we end up in this case we need to find out how it happened and fix.
When picking up a header to notarize it, and adding it to usedInBlock then it should have already been checked that there is a valid proof for it.

usedInBlock field is set to true also when shard headers are requested.. it is basically set in advance to true, even though the header is missing.. so maybe the proof would be received later.. not sure if this is possible though

process/block/metablock.go

AdoAdoAdo · 2024-10-04T15:09:39Z

process/block/metablock.go

@@ -1838,6 +1867,20 @@ func (mp *metaProcessor) checkShardHeadersFinality(
 			continue
 		}

+		if mp.enableEpochsHandler.IsFlagEnabledInEpoch(common.EquivalentMessagesFlag, lastVerifiedHdr.GetEpoch()) {


I don't think this loop is correct, as it does not get to iterate over all shard headers and verify.
it returns either a nil or an error in the first iteration.

true, moved this if into the next for loop and switched the return nil into a break

AdoAdoAdo · 2024-10-07T13:30:47Z

process/block/metablock.go

+			hasProof := mp.proofsPool.HasProof(shardHeader.GetShardID(), shardHeaderHash)
+			hdrInfoForHash.hasProof = hasProof
+			if hasProof {
+				mp.hdrsForCurrBlock.missingHdrsProofs--


missingHdrsProofs should be decreased if that proof was missing previously and still missing at this step only

e.g you receive a shard hdr which is not part of the metablock (an older block maybe), so here you would end up decreasing the missing headers proofs.

updated the condition, it was not working as expected

process/block/metablock.go

AdoAdoAdo · 2024-10-07T14:25:52Z

process/block/metablock.go

+			mp.enableEpochsHandler.IsFlagEnabledInEpoch(common.EquivalentMessagesFlag, headerInfo.hdr.GetEpoch())
+		hasMissingProof := isBlockAfterEquivalentMessagesFlag && !headerInfo.hasProof
+		if hasMissingProof {
+			continue


this is an error if a header was used in block but has no proof, should not continue but return an error.
If we get such errors, then we need to fix in the place where the headers are notarized, as there should be the check that the notarized headers have the proper proof.

Please check that the shardInfo (createShardInfo) contains the proof for the shard header itself, along with the proof for the previous block.
This means that the shardInfo would change as well to include 2 proofs.

updated to return error

updated also to use both proofs

AdoAdoAdo · 2024-10-07T15:37:13Z

process/block/shardblock.go

-				core.MetachainShardId,
-				sp.metaBlockFinality,
-			)
+			if !sp.shouldConsiderProofsForNotarization(metaBlock) {


on the else, you should at least check that there is a valid proof for this metablock, otherwise add it to the missing proofs.

AdoAdoAdo · 2024-10-07T15:38:18Z

process/block/metablock.go

 		if mp.hdrsForCurrBlock.missingHdrs == 0 {
-			mp.hdrsForCurrBlock.missingFinalityAttestingHdrs = mp.requestMissingFinalityAttestingShardHeaders()
+			if !mp.shouldConsiderProofsForNotarization(shardHeader) {


on the else, you should check that there is a valid proof for this header, otherwise add it to the missing proofs.

AdoAdoAdo · 2024-10-07T15:41:29Z

process/block/shardblock.go

+			hasProofForShardHdr := sp.proofsPool.HasProof(core.MetachainShardId, metaBlockHashes[i])
+			sp.hdrsForCurrBlock.hdrHashAndInfo[string(metaBlockHashes[i])].hasProof = hasProofForShardHdr
+			if !hasProofForShardHdr {
+				sp.hdrsForCurrBlock.missingHdrsProofs++


maybe add the header hash in a map for missing proofs instead?

moved the logic to be based on hasProof field, which is part of a map too

ssd04 · 2024-10-08T11:30:30Z

process/block/hdrForBlock.go

@@ -9,6 +9,7 @@ import (
 type hdrForBlock struct {
 	missingHdrs                  uint32
 	missingFinalityAttestingHdrs uint32
+	missingHdrsProofs            uint32


i might help to rename here to indicate that it's num missing

ssd04 · 2024-10-08T11:33:05Z

process/block/metablock.go

 		if len(currShardHdr.GetMiniBlockHeadersWithDst(mp.shardCoordinator.SelfId())) == 0 {
-			mp.hdrsForCurrBlock.hdrHashAndInfo[string(orderedHdrsHashes[i])] = &hdrInfo{hdr: currShardHdr, usedInBlock: true}
+			mp.hdrsForCurrBlock.hdrHashAndInfo[string(orderedHdrsHashes[i])] = &hdrInfo{hdr: currShardHdr, usedInBlock: true, hasProof: true}


split on multiple lines for better visibility? same below

ssd04 · 2024-10-08T11:36:45Z

process/block/metablock.go

@@ -1081,8 +1089,18 @@ func (mp *metaProcessor) createAndProcessCrossMiniBlocksDstMe(
 			continue
 		}

+		shouldCheckProof := mp.enableEpochsHandler.IsFlagEnabledInEpoch(common.EquivalentMessagesFlag, currShardHdr.GetEpoch())
+		hasProofForHdr := mp.proofsPool.HasProof(currShardHdr.GetShardID(), orderedHdrsHashes[i])


i think here we should check if HasProof only if shouldCheckProof is true

correct, optimization.. implemented it

ssd04 · 2024-10-08T12:03:17Z

process/block/baseProcess.go

adapt also sortHeadersForCurrentBlockByNonce to have hasProof check?

ssd04 · 2024-10-08T13:07:12Z

process/block/baseProcess.go

@@ -639,7 +642,7 @@ func (bp *baseProcessor) sortHeaderHashesForCurrentBlockByNonce(usedInBlock bool

 	bp.hdrsForCurrBlock.mutHdrsForBlock.RLock()
 	for metaBlockHash, headerInfo := range bp.hdrsForCurrBlock.hdrHashAndInfo {
-		if headerInfo.usedInBlock != usedInBlock {
+		if headerInfo.usedInBlock != usedInBlock || !headerInfo.hasProof {


check for enabled flag here?

ssd04 · 2024-10-08T13:21:57Z

process/block/metablock.go

@@ -1838,6 +1867,20 @@ func (mp *metaProcessor) checkShardHeadersFinality(
 			continue
 		}

+		if mp.enableEpochsHandler.IsFlagEnabledInEpoch(common.EquivalentMessagesFlag, lastVerifiedHdr.GetEpoch()) {


does it fits better to check proof in checkShardHeadersValidity which is called just before instead of here?

I think it should stay here, as here is the place where we check for finality

ssd04 · 2024-10-08T13:44:18Z

process/block/shardblock.go

+
+		headerHash := sp.hasher.Compute(string(marshalledHeader))
+		if !sp.proofsPool.HasProof(header.GetShardID(), headerHash) {
+			return process.ErrHeaderNotFinal


return a composed error here to indicate also that the proof is missing?

ssd04 · 2024-10-08T13:45:37Z

process/block/shardblock.go

 		createAndProcessInfo.currMetaHdrHash = orderedMetaBlocksHashes[i]
 		if len(createAndProcessInfo.currMetaHdr.GetMiniBlockHeadersWithDst(sp.shardCoordinator.SelfId())) == 0 {
-			sp.hdrsForCurrBlock.hdrHashAndInfo[string(createAndProcessInfo.currMetaHdrHash)] = &hdrInfo{hdr: createAndProcessInfo.currMetaHdr, usedInBlock: true}
+			sp.hdrsForCurrBlock.hdrHashAndInfo[string(createAndProcessInfo.currMetaHdrHash)] = &hdrInfo{hdr: createAndProcessInfo.currMetaHdr, usedInBlock: true, hasProof: true}


suggestion to expand on multiple lines

…rsx/mx-chain-go into adapt_notarization # Conflicts: # process/block/baseProcess.go

…otarization

…rsx/mx-chain-go into adapt_notarization # Conflicts: # integrationTests/multiShard/endOfEpoch/startInEpoch/startInEpoch_test.go # integrationTests/multiShard/hardFork/hardFork_test.go # process/block/shardblock.go

…more with the new flow

ssd04 · 2024-11-14T15:14:36Z

process/block/metablock.go

+	// check proofs for shard data
+	for _, shardData := range header.ShardInfo {


i think here we should do this only if equivalent messages flag is activated

ssd04 · 2024-11-14T15:15:03Z

process/block/metablock.go

+			// if there is an entry for the missing proof, it means that proofsPool did not have it while scanning shardData
+			// thus header epoch was not available at that time
+			incompleteProof, hasMissingProof := mp.hdrsForCurrBlock.missingProofs[string(shardHeaderHash)]


i think here also

ssd04 · 2024-11-14T15:15:45Z

process/block/metablock.go

 	}

-	if mp.hdrsForCurrBlock.missingHdrs == 0 {
+	shouldRequestMissingFinalityAttestingShardHeaders := notarizedShardHdrsBasedOnProofs != len(metaBlock.ShardInfo)


check this only if equivalent flag enabled?

not needed, here notarizedShardHdrsBasedOnProofs would be 0, thus the second condition will always be true

ssd04 · 2024-11-14T15:16:03Z

process/block/shardblock.go

+	// check proofs for shard data
+	for _, metaBlockHash := range header.GetMetaBlockHashes() {


check if proofs activated?

ssd04 · 2024-11-14T15:16:20Z

process/block/shardblock.go

 	}

-	if sp.hdrsForCurrBlock.missingHdrs == 0 {
+	shouldRequestMissingFinalityAttestingMetaHeaders := notarizedMetaHdrsBasedOnProofs != len(metaBlockHashes)


add this only if flag activated

this should be ok too

AdoAdoAdo · 2024-11-18T14:01:07Z

consensus/spos/bls/v2/subroundBlock.go

@@ -361,44 +359,29 @@ func (sr *subroundBlock) createHeader() (data.HeaderHandler, error) {
 	return hdr, nil
 }

+func (sr *subroundBlock) isEpochChangeBlockForEquivalentMessagesActivation(header data.HeaderHandler) bool {
+	isEquivalentMessagesFlagEnabledForHeader := sr.EnableEpochsHandler().IsFlagEnabledInEpoch(common.EquivalentMessagesFlag, header.GetEpoch())


do we still need this if we have condition at line 365?

no, deleted

AdoAdoAdo · 2024-11-18T14:52:43Z

process/block/baseProcess.go

+}
+
+func (bp *baseProcessor) isEpochChangeBlockForEquivalentMessagesActivation(header data.HeaderHandler) bool {
+	isEquivalentMessagesFlagEnabledForHeader := bp.enableEpochsHandler.IsFlagEnabledInEpoch(common.EquivalentMessagesFlag, header.GetEpoch())


this condition seems to be redundant.
also can we extract this as a separate function and call it from consensus and base process as well?
it can get the enableEpochsHandler as argument then it doesn't need to be a method.

I was thinking about this.. applied the suggestion, extended the method to work for any given flag

AdoAdoAdo · 2024-11-18T14:54:54Z

process/block/baseProcess.go

-	for _, headerInfo := range bp.hdrsForCurrBlock.hdrHashAndInfo {
-		if headerInfo.usedInBlock != usedInBlock {
+	for hdrHash, headerInfo := range bp.hdrsForCurrBlock.hdrHashAndInfo {
+		isFlagEnabledForHeader := bp.enableEpochsHandler.IsFlagEnabledInEpoch(common.EquivalentMessagesFlag, headerInfo.hdr.GetEpoch())


I think we can extract the code from L623-625 in a function and call it here and at line 646

applied the suggestion

AdoAdoAdo · 2024-11-19T10:18:06Z

process/track/blockProcessor.go

@@ -300,6 +315,19 @@ func (bp *blockProcessor) checkHeaderFinality(
 		return process.ErrNilBlockHeader
 	}

+	if bp.enableEpochsHandler.IsFlagEnabledInEpoch(common.EquivalentMessagesFlag, header.GetEpoch()) {
+		headerHash, err := core.CalculateHash(bp.marshaller, bp.hasher, header)


I think the hash can be passed, as it is available in ComputeLongestChain, so that we won't have to recompute here.

Also here we need to be careful about the first header in the epoch, as it is only final if it has a confirmation (for it the finality works by the old rules).

IsEpochChangeBlockForEquivalentMessagesActivation can be used for that, so the condition above could be changed to something like

equivalentMessagesActive := bp.enableEpochsHandler.IsFlagEnabledInEpoch(common.EquivalentMessagesFlag, header.GetEpoch()) if equivalentMessagesActive && !IsEpochChangeBlockForEquivalentMessagesActivation() { .... }

applied both suggestions, indeed the hashes were available, sorted

AdoAdoAdo · 2024-11-19T10:53:03Z

process/track/blockProcessor.go

@@ -234,7 +245,11 @@ func (bp *blockProcessor) ComputeLongestChain(shardID uint32, header data.Header
 		go bp.requestHeadersIfNeeded(header, sortedHeaders, headers)
 	}()

-	sortedHeaders, sortedHeadersHashes = bp.blockTracker.SortHeadersFromNonce(shardID, header.GetNonce()+1)
+	startingNonce := header.GetNonce() + 1
+	if bp.enableEpochsHandler.IsFlagEnabledInEpoch(common.EquivalentMessagesFlag, header.GetEpoch()) {


I don't think we need this condition here, as the header received as argument should be the last notarized header, not the header that needs to be processed next.

In this case both with previous and with the next version of consensus the starting nonce should be the same (next nonce after the nonce of the last notarized header)

Could you confirm this (I may remember this wrongly)?

right, the header is the last notarized header.. updated as suggested

AdoAdoAdo · 2024-11-21T11:49:39Z

process/block/metablock.go

+					PubKeysBitmap:       shardData.CurrentPubKeysBitmap,
+					AggregatedSignature: shardData.CurrentSignature,
+					HeaderHash:          shardData.HeaderHash,
+					HeaderEpoch:         hdr.GetEpoch(),


shardData.Epoch?

AdoAdoAdo · 2024-11-21T12:24:02Z

process/block/metablock.go

 			}
+			shardData.CurrentPubKeysBitmap = currentProof.GetPubKeysBitmap()
+			shardData.CurrentSignature = currentProof.GetAggregatedSignature()


also set the epoch.

AdoAdoAdo · 2024-11-21T12:32:59Z

process/block/shardblock.go

@@ -291,6 +293,15 @@ func (sp *shardProcessor) ProcessBlock(
 		return process.ErrAccountStateDirty
 	}

+	if sp.enableEpochsHandler.IsFlagEnabledInEpoch(common.EquivalentMessagesFlag, header.GetEpoch()) {
+		// check proofs for shard data


this is for referenced metablock proofs

process/block/shardblock.go

AdoAdoAdo · 2024-11-21T13:14:45Z

process/block/shardblock.go

+			log.Trace("no proof for meta header",
+				"hash", logger.DisplayByteSlice(orderedMetaBlocksHashes[i]),
+			)
+			continue


I think this should be break, continuing will iterate on the next metablock, which will break at line 1944 (the metablocks are ordered by nonce)

missed that.. updated

ssd04 · 2024-11-22T10:37:10Z

consensus/spos/bls/v2/subroundBlock.go

-		header.SetPreviousProof(proof)
-		return true
-	}
+	log.Debug("addProofOnHeader: no proof found")


log also header hash?

i did not realized that we need to calculate hash here, it might not help to add more processing only for logging

ssd04 · 2024-11-22T10:41:29Z

process/block/baseProcess.go

@@ -2175,3 +2183,17 @@ func (bp *baseProcessor) checkSentSignaturesAtCommitTime(header data.HeaderHandl

 	return nil
 }
+
+func (bp *baseProcessor) isFirstBlock(header data.HeaderHandler) bool {


more specific naming? like isFirstBlockInEpoch?

ssd04 · 2024-11-22T11:40:13Z

process/block/metablock.go

+			prevProof := shardHdr.GetPreviousProof()
+			if prevProof != nil {
+				shardData.PubKeysBitmap = prevProof.GetPubKeysBitmap()
+				shardData.Signature = prevProof.GetAggregatedSignature()
+				err := shardData.SetPreviousProof(prevProof)


why do we set here pubkeysbitmap and signature from previous proof?

because now the bitmap + signature from block are part of the proof of the previous block

ssd04 · 2024-11-22T11:57:58Z

process/block/shardblock.go

+		hasProofForMetablock := false
 		// attesting something
 		if sp.hdrsForCurrBlock.missingHdrs == 0 {
-			sp.hdrsForCurrBlock.missingFinalityAttestingHdrs = sp.requestMissingFinalityAttestingHeaders(
-				core.MetachainShardId,
-				sp.metaBlockFinality,
-			)
+			hasProofForMetablock = sp.hasProofForMetablock(metaBlockHash, metaBlock)


is might be cleaner to keep old code here and set hasProofForMetablock to true initially, and then set it based on HasProof if flag is enabled

AdoAdoAdo · 2024-12-02T14:33:39Z

consensus/spos/bls/v2/subroundBlock.go

@@ -364,41 +363,23 @@ func (sr *subroundBlock) createHeader() (data.HeaderHandler, error) {
 func (sr *subroundBlock) addProofOnHeader(header data.HeaderHandler) bool {
 	prevBlockProof, err := sr.EquivalentProofsPool().GetProof(sr.ShardCoordinator().SelfId(), sr.GetData())


I don't think this is correct.

sr.GetData would return the current block header hash, so this is not prevBlockProof but it is instead current block proof.
the previousBlockProof should be taken with key header.PrevHash

indeed.. found out during testing, sr.GetData() would be anyway empty here, as it is reset before, thus it was always returning that the proof does not exists

applied the suggestion

AdoAdoAdo · 2024-12-02T15:11:37Z

process/block/baseProcess.go

@@ -617,8 +619,8 @@ func (bp *baseProcessor) sortHeadersForCurrentBlockByNonce(usedInBlock bool) map
 	hdrsForCurrentBlock := make(map[uint32][]data.HeaderHandler)

 	bp.hdrsForCurrBlock.mutHdrsForBlock.RLock()
-	for _, headerInfo := range bp.hdrsForCurrBlock.hdrHashAndInfo {
-		if headerInfo.usedInBlock != usedInBlock {
+	for hdrHash, headerInfo := range bp.hdrsForCurrBlock.hdrHashAndInfo {


The method sortHeadersForCurrentBlockByNonce is currently used in two contexts:

when called with true (usedInBlock) it returns all the headers used in block, ordered by nonce - will be used to check the validity of all included headers in a block - checkShardHeadersValidity, checkMetaHeadersValidityAndFinality

when called with false (usedInBlock) it returns all the headers not used explicitly in the block, but implicitly to check for finality in the context of confirmation blocks. - will be used to check the finality of all the included headers in a block - checkShardHeadersFinality, checkMetaHdrFinality

The function shouldSkipHeader mixes the fact that a header is required for the operation, with the existence of the proof.
I would suggest to keep the condition as before, and treat the lack of a proof separately.

updated to keep the old check and return error

AdoAdoAdo · 2024-12-03T09:15:03Z

process/block/baseProcess.go

@@ -666,6 +668,12 @@ func (bp *baseProcessor) sortHeaderHashesForCurrentBlockByNonce(usedInBlock bool
 	return hdrsHashesForCurrentBlock
 }

+func (bp *baseProcessor) shouldSkipHeader(headerInfo *hdrInfo, usedInBlock bool, hdrHash string) bool {


check my previous comment, I would treat the missing proof separately.

The effect needs to be that if there is a missing proof for a header that is either notarized or used to decide the finality of a notarized header (only applies to the first and second block in the activation epoch), then the block needs to not be signed in consensus, or if this is the proposer perspective, the notarized header (that either is notarized but doesn't have a proof, or is given finality through confirmation by a block that doesn't have a proof) needs to be dropped.

AdoAdoAdo · 2024-12-03T09:31:41Z

process/block/metablock.go

@@ -340,6 +341,18 @@ func (mp *metaProcessor) ProcessBlock(
 		}
 	}

+	if mp.enableEpochsHandler.IsFlagEnabledInEpoch(common.EquivalentMessagesFlag, header.Epoch) {


can you extract this in a method and call it here?

process/block/metablock.go

AdoAdoAdo · 2024-12-03T10:01:34Z

process/block/metablock.go

+						log.Trace("could not add the constructed proof after header received", "hash", hex.EncodeToString(incompleteProof.HeaderHash))
+					}
+
+					delete(mp.hdrsForCurrBlock.missingProofs, string(shardHeaderHash))


I don't think this is correct, as the missing proof here is deleted even if it is not correct (errAddProof != nil). We still have a missing proof (we don't yet have a correct one)

AdoAdoAdo · 2024-12-03T11:30:58Z

process/block/metablock.go

@@ -1982,6 +2076,9 @@ func (mp *metaProcessor) computeExistingAndRequestMissingShardHeaders(metaBlock
 				hdr:         nil,
 				usedInBlock: true,
 			}
+
+			mp.hdrsForCurrBlock.missingProofs[string(shardData.HeaderHash)] = shardData.CurrentShardHeaderProof


Is this correct?
maybe we can discuss it

removed the concept of missing proofs

AdoAdoAdo · 2024-12-03T11:34:13Z

process/block/metablock.go

+			hasProofForShardHdr := mp.proofsPool.HasProof(shardData.ShardID, shardData.HeaderHash)
+			if !hasProofForShardHdr {
+				// TODO: consider verifying the proof before adding it into the proofsPool
+				errAddProof := mp.proofsPool.AddProof(shardData.CurrentShardHeaderProof)


Is the addProof doing also the proof verification?
Let's discuss this as well.

no, it doesn't, thus the TODO.. indeed, let's discuss it and perhaps fix in a new PR

AdoAdoAdo · 2024-12-03T11:38:11Z

process/block/metablock.go

-				shardData.PubKeysBitmap = proof.GetPubKeysBitmap()
+			prevProof := shardHdr.GetPreviousProof()
+			if prevProof != nil {
+				shardData.PubKeysBitmap = prevProof.GetPubKeysBitmap()


I don't think I understand this part.
We have now separate fields for current proof and previous proof, we wouldn't need to set the shardData.PubKeysBitmap and shardData.Signature

indeed, updated

process/block/metablock.go

AdoAdoAdo · 2024-12-04T09:28:39Z

process/block/metablock.go

@@ -1832,6 +1850,11 @@ func (mp *metaProcessor) checkShardHeadersValidity(metaHdr *block.MetaBlock) (ma
 			return nil, process.ErrDeveloperFeesDoNotMatch
 		}

+		err = mp.verifyShardDataProofs(shardData)


this will be expensive verify here, we need to see if we can move it to the interceptor instead, so that if we accept the metablock, these checks are already done.

I think the proof checks could also be done on go routines.

process/block/metablock.go

AdoAdoAdo · 2024-12-04T11:11:02Z

process/block/interceptedBlocks/common.go

+		return fmt.Errorf("%w for previous block", err)
+	}
+
+	err = checkProof(shardData.GetCurrentProof())


I would suggest to remove the current proof from the sharddata
the proof is anyway checked when making sure the headers that generated the shard data are available and have proofs.

AdoAdoAdo · 2024-12-04T14:36:16Z

process/block/interceptedBlocks/common_test.go

 	assert.Nil(t, err)
 }

+func TestCheckMetaShardInfo_OkValsShouldWorkMultipleShardData(t *testing.T) {


I think the name is not good as it tests for errors

AdoAdoAdo · 2024-12-05T13:13:21Z

process/block/metablock.go

@@ -1800,6 +1865,24 @@ func (mp *metaProcessor) checkShardHeadersValidity(metaHdr *block.MetaBlock) (ma
 	return highestNonceHdrs, nil
 }

+func (mp *metaProcessor) verifyProof(proof data.HeaderProofHandler) error {


This can be a function, no need for the receiver

now metachain notarizez based on equivalent proofs

1eae0e9

sstanculeanu added type:feature New feature or request area:processing impact:medium interested:protocol complexity:medium labels Oct 2, 2024

sstanculeanu self-assigned this Oct 2, 2024

sstanculeanu marked this pull request as ready for review October 3, 2024 06:53

sstanculeanu added 2 commits October 3, 2024 12:30

Merge branch 'feat/equivalent-messages' into adapt_notarization

4197d2b

Merge branch 'feat/equivalent-messages' into adapt_notarization

71187d1

AdoAdoAdo reviewed Oct 7, 2024

View reviewed changes

ssd04 reviewed Oct 8, 2024

View reviewed changes

sstanculeanu and others added 13 commits October 10, 2024 10:45

Merge branch 'feat/equivalent-messages' of https://github.com/multive…

367d1d1

…rsx/mx-chain-go into adapt_notarization # Conflicts: # process/block/baseProcess.go

Merge remote-tracking branch 'origin/adapt_notarization' into adapt_n…

3df3761

…otarization

fixes after review

8236823

fixed more tests

d96462a

fix after merge

2e1b145

Merge branch 'feat/equivalent-messages' into adapt_notarization

f34b5cf

fix tests

6aad53b

subround block fixes

50ba8a1

removed tests for after equivalent messages as they are not valid any…

3fb045b

…more with the new flow

fix linter

93afc4e

remove one more test

1158d33

proper proofs verification on notarization

450d335

ssd04 requested changes Nov 14, 2024

View reviewed changes

fixes after review

644d8be

AdoAdoAdo requested changes Nov 21, 2024

View reviewed changes

fixes after review

d9e38c4

ssd04 reviewed Nov 22, 2024

View reviewed changes

sstanculeanu added 2 commits November 22, 2024 17:25

fixed IsFlagEnabledAfterEpochsStartBlock

50b7ecb

fixes after review

12bdda4

AdoAdoAdo requested changes Dec 3, 2024

View reviewed changes

sstanculeanu added 2 commits December 3, 2024 18:37

fixes after review

7ce8e27

early exit for nil proof

f334d9d

AdoAdoAdo reviewed Dec 4, 2024

View reviewed changes

more fixes after review

10c8d22

AdoAdoAdo reviewed Dec 5, 2024

View reviewed changes

fixes after review

b110475

AdoAdoAdo approved these changes Dec 9, 2024

View reviewed changes

ssd04 approved these changes Dec 9, 2024

View reviewed changes

sstanculeanu merged commit 3facbdf into feat/equivalent-messages Dec 9, 2024
5 checks passed

sstanculeanu deleted the adapt_notarization branch December 9, 2024 12:14

		// check proofs for shard data
		for _, shardData := range header.ShardInfo {

		// check proofs for shard data
		for _, metaBlockHash := range header.GetMetaBlockHashes() {

		@@ -364,41 +363,23 @@ func (sr *subroundBlock) createHeader() (data.HeaderHandler, error) {
		func (sr *subroundBlock) addProofOnHeader(header data.HeaderHandler) bool {
		prevBlockProof, err := sr.EquivalentProofsPool().GetProof(sr.ShardCoordinator().SelfId(), sr.GetData())

Metachain notarizez based on equivalent proofs #6513

Metachain notarizez based on equivalent proofs #6513

Conversation

sstanculeanu commented Oct 2, 2024

Reasoning behind the pull request

Proposed changes

Testing procedure

Pre-requisites

Choose a reason for hiding this comment

sstanculeanu Oct 10, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

sstanculeanu Oct 10, 2024 •

edited

Loading