From 176488a17b6923001cd15fcb6706d55674ab6916 Mon Sep 17 00:00:00 2001 From: joanestebanr <129153821+joanestebanr@users.noreply.github.com> Date: Tue, 3 Dec 2024 10:57:56 +0100 Subject: [PATCH 01/11] feat: limit cert by estimated size --- aggsender/aggsender.go | 47 ++++++++++++++++++++++++++++++++++++++---- aggsender/config.go | 3 +++ config/default.go | 2 ++ 3 files changed, 48 insertions(+), 4 deletions(-) diff --git a/aggsender/aggsender.go b/aggsender/aggsender.go index 4075508a..f8522817 100644 --- a/aggsender/aggsender.go +++ b/aggsender/aggsender.go @@ -187,12 +187,12 @@ func (a *AggSender) sendCertificate(ctx context.Context) (*agglayer.SignedCertif return nil, nil } - claims, err := a.l2Syncer.GetClaims(ctx, fromBlock, toBlock) + toBlock, bridges, claims, err := a.limitCertSize(ctx, fromBlock, toBlock) if err != nil { - return nil, fmt.Errorf("error getting claims: %w", err) + return nil, fmt.Errorf("error limitCertSize: %w", err) } - - a.log.Infof("building certificate for block: %d to block: %d", fromBlock, toBlock) + a.log.Infof("building certificate for block: %d to block: %d, numBridges=%d, numClaims=%d estimatedSize=%d", fromBlock, toBlock, + len(bridges), len(claims), a.estimateSizeCert(len(bridges), len(claims))) certificate, err := a.buildCertificate(ctx, bridges, claims, lastSentCertificateInfo, toBlock) if err != nil { @@ -265,6 +265,45 @@ func (a *AggSender) saveCertificateToStorage(ctx context.Context, cert types.Cer return nil } +const ( + estimatedSizeBridgeExit = 250 + estimatedSizeClaim = 44000 +) + +func (a *AggSender) limitCertSize(ctx context.Context, fromBlock, toBlock uint64) (uint64, []bridgesync.Bridge, []bridgesync.Claim, error) { + var err error + var bridges, previousBridges []bridgesync.Bridge + var claims, previousClaims []bridgesync.Claim + for true { + bridges, err = a.l2Syncer.GetBridgesPublished(ctx, fromBlock, toBlock) + if err != nil { + return 0, nil, nil, fmt.Errorf("error getting bridges: %w", err) + } + claims, err = a.l2Syncer.GetClaims(ctx, fromBlock, toBlock) + if err != nil { + return 0, nil, nil, fmt.Errorf("error getting claims: %w", err) + } + if len(bridges) == 0 { + // We can't reduce more the certificate, so this is the minium size + a.log.Warnf("We reach the minium size of bridge: %d that is bigger than the max size of certificate: %d", + a.estimateSizeCert(len(previousBridges), len(previousClaims)), a.cfg.MaxCertSize) + return toBlock + 1, previousBridges, previousClaims, nil + } + if toBlock == 0 || a.cfg.MaxCertSize == 0 || a.estimateSizeCert(len(bridges), len(claims)) < a.cfg.MaxCertSize { + return toBlock, bridges, claims, nil + } + // We have to reduce the number of blocks + toBlock-- + previousBridges = bridges + previousClaims = claims + } + +} + +func (a *AggSender) estimateSizeCert(numBridges, numClaims int) uint { + return uint(numBridges*estimatedSizeBridgeExit + numClaims*estimatedSizeClaim) +} + // saveCertificate saves the certificate to a tmp file func (a *AggSender) saveCertificateToFile(signedCertificate *agglayer.SignedCertificate) { if signedCertificate == nil || a.cfg.SaveCertificatesToFilesPath == "" { diff --git a/aggsender/config.go b/aggsender/config.go index cfd0b63c..ec7fb6c5 100644 --- a/aggsender/config.go +++ b/aggsender/config.go @@ -38,6 +38,9 @@ type Config struct { DelayBeetweenRetries types.Duration `mapstructure:"DelayBeetweenRetries"` // KeepCertificatesHistory is a flag to keep the certificates history on storage KeepCertificatesHistory bool `mapstructure:"KeepCertificatesHistory"` + // MaxCertSize is the maximum size of the certificate (the emitted certificate can be bigger that this size) + // 0 is infinite + MaxCertSize uint `mapstructure:"MaxCertSize"` } // String returns a string representation of the Config diff --git a/config/default.go b/config/default.go index 6a505b88..50dfc9f5 100644 --- a/config/default.go +++ b/config/default.go @@ -340,4 +340,6 @@ SaveCertificatesToFilesPath = "" MaxRetriesStoreCertificate = 3 DelayBeetweenRetries = "60s" KeepCertificatesHistory = true +# MaxSize of the certificate to 8Mb +MaxCertSize = 8388608 ` From 0e6cb40412f38cb1fb66a659ab25c6fab276e768 Mon Sep 17 00:00:00 2001 From: joanestebanr <129153821+joanestebanr@users.noreply.github.com> Date: Tue, 3 Dec 2024 11:08:27 +0100 Subject: [PATCH 02/11] fix: build --- aggsender/aggsender.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/aggsender/aggsender.go b/aggsender/aggsender.go index f8522817..3259e303 100644 --- a/aggsender/aggsender.go +++ b/aggsender/aggsender.go @@ -297,7 +297,7 @@ func (a *AggSender) limitCertSize(ctx context.Context, fromBlock, toBlock uint64 previousBridges = bridges previousClaims = claims } - + return 0, nil, nil, fmt.Errorf("error reducing the size of the certificate") } func (a *AggSender) estimateSizeCert(numBridges, numClaims int) uint { From 914497f6d817a7c877d17637c98d273a642806ba Mon Sep 17 00:00:00 2001 From: joanestebanr <129153821+joanestebanr@users.noreply.github.com> Date: Tue, 3 Dec 2024 11:19:20 +0100 Subject: [PATCH 03/11] fix: lint --- aggsender/aggsender.go | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/aggsender/aggsender.go b/aggsender/aggsender.go index 3259e303..7d262c97 100644 --- a/aggsender/aggsender.go +++ b/aggsender/aggsender.go @@ -191,8 +191,8 @@ func (a *AggSender) sendCertificate(ctx context.Context) (*agglayer.SignedCertif if err != nil { return nil, fmt.Errorf("error limitCertSize: %w", err) } - a.log.Infof("building certificate for block: %d to block: %d, numBridges=%d, numClaims=%d estimatedSize=%d", fromBlock, toBlock, - len(bridges), len(claims), a.estimateSizeCert(len(bridges), len(claims))) + a.log.Infof("building certificate for block: %d to block: %d, numBridges=%d, numClaims=%d estimatedSize=%d", + fromBlock, toBlock, len(bridges), len(claims), a.estimateSizeCert(len(bridges), len(claims))) certificate, err := a.buildCertificate(ctx, bridges, claims, lastSentCertificateInfo, toBlock) if err != nil { @@ -270,7 +270,8 @@ const ( estimatedSizeClaim = 44000 ) -func (a *AggSender) limitCertSize(ctx context.Context, fromBlock, toBlock uint64) (uint64, []bridgesync.Bridge, []bridgesync.Claim, error) { +func (a *AggSender) limitCertSize(ctx context.Context, fromBlock, toBlock uint64) (uint64, + []bridgesync.Bridge, []bridgesync.Claim, error) { var err error var bridges, previousBridges []bridgesync.Bridge var claims, previousClaims []bridgesync.Claim From b9f6c51330e1c77d29c73a768862a29400ae5f86 Mon Sep 17 00:00:00 2001 From: joanestebanr <129153821+joanestebanr@users.noreply.github.com> Date: Tue, 3 Dec 2024 11:24:41 +0100 Subject: [PATCH 04/11] fix: ut --- aggsender/aggsender_test.go | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/aggsender/aggsender_test.go b/aggsender/aggsender_test.go index 766ad1ad..fc36ab05 100644 --- a/aggsender/aggsender_test.go +++ b/aggsender/aggsender_test.go @@ -993,7 +993,7 @@ func TestSendCertificate(t *testing.T) { mockL2Syncer.On("GetLastProcessedBlock", mock.Anything).Return(cfg.lastL2BlockProcessed...).Once() if cfg.getBridges != nil { - mockL2Syncer.On("GetBridgesPublished", mock.Anything, mock.Anything, mock.Anything).Return(cfg.getBridges...).Once() + mockL2Syncer.On("GetBridgesPublished", mock.Anything, mock.Anything, mock.Anything).Return(cfg.getBridges...) } if cfg.getClaims != nil { @@ -1643,8 +1643,6 @@ func TestGetNextHeightAndPreviousLER(t *testing.T) { } func TestSendCertificate_NoClaims(t *testing.T) { - t.Parallel() - privateKey, err := crypto.GenerateKey() require.NoError(t, err) @@ -1690,8 +1688,8 @@ func TestSendCertificate_NoClaims(t *testing.T) { Metadata: []byte("metadata"), DepositCount: 1, }, - }, nil).Once() - mockL2Syncer.On("GetClaims", mock.Anything, uint64(11), uint64(50)).Return([]bridgesync.Claim{}, nil).Once() + }, nil) + mockL2Syncer.On("GetClaims", mock.Anything, uint64(11), uint64(50)).Return([]bridgesync.Claim{}, nil) mockL2Syncer.On("GetExitRootByIndex", mock.Anything, uint32(1)).Return(treeTypes.Root{}, nil).Once() mockL2Syncer.On("OriginNetwork").Return(uint32(1), nil).Once() mockAggLayerClient.On("SendCertificate", mock.Anything).Return(common.Hash{}, nil).Once() From 5afca3ede920b3efaf49f1aec4a5f1e555d1724a Mon Sep 17 00:00:00 2001 From: joanestebanr <129153821+joanestebanr@users.noreply.github.com> Date: Tue, 3 Dec 2024 11:41:55 +0100 Subject: [PATCH 05/11] fix: increase coverage --- aggsender/aggsender_test.go | 60 +++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) diff --git a/aggsender/aggsender_test.go b/aggsender/aggsender_test.go index fc36ab05..5938e396 100644 --- a/aggsender/aggsender_test.go +++ b/aggsender/aggsender_test.go @@ -1915,6 +1915,63 @@ func TestCheckLastCertificateFromAgglayer_Case4ErrorUpdateStatus(t *testing.T) { require.Error(t, err) } +func TestLimitSize_FirstOneFit(t *testing.T) { + testData := newAggsenderTestData(t, testDataFlagMockStorage) + fromBlock := uint64(1) + toBlock := uint64(20) + // It returns 1 bridge + testData.l2syncerMock.EXPECT().GetBridgesPublished(testData.ctx, fromBlock, toBlock).Return([]bridgesync.Bridge{ + {}, + }, nil) + testData.l2syncerMock.EXPECT().GetClaims(testData.ctx, fromBlock, toBlock).Return([]bridgesync.Claim{}, nil) + newToBlock, _, _, err := testData.sut.limitCertSize(testData.ctx, fromBlock, toBlock) + require.NoError(t, err) + require.Equal(t, toBlock, newToBlock) +} + +func TestLimitSize_FirstMinusOneFit(t *testing.T) { + testData := newAggsenderTestData(t, testDataFlagMockStorage) + testData.sut.cfg.MaxCertSize = (estimatedSizeBridgeExit * 3) + 1 + fromBlock := uint64(1) + toBlock := uint64(20) + // It returns 4 bridge + testData.l2syncerMock.EXPECT().GetBridgesPublished(testData.ctx, fromBlock, toBlock).Return([]bridgesync.Bridge{ + {}, {}, {}, {}, + }, nil).Once() + + // fromBlock is 1, toBlock is 20, so it will return 3 + testData.l2syncerMock.EXPECT().GetBridgesPublished(testData.ctx, fromBlock, toBlock-1).Return([]bridgesync.Bridge{ + {}, {}, {}, + }, nil).Once() + testData.l2syncerMock.EXPECT().GetClaims(testData.ctx, fromBlock, mock.Anything).Return([]bridgesync.Claim{}, nil) + newToBlock, _, _, err := testData.sut.limitCertSize(testData.ctx, fromBlock, toBlock) + require.NoError(t, err) + require.Equal(t, toBlock-1, newToBlock) +} + +func TestLimitSize_NoWayToFitInMaxSize(t *testing.T) { + testData := newAggsenderTestData(t, testDataFlagMockStorage) + testData.sut.cfg.MaxCertSize = (estimatedSizeBridgeExit * 2) + 1 + fromBlock := uint64(1) + toBlock := uint64(20) + // It returns 4 bridge + testData.l2syncerMock.EXPECT().GetBridgesPublished(testData.ctx, fromBlock, toBlock).Return([]bridgesync.Bridge{ + {}, {}, {}, {}, + }, nil).Once() + + // fromBlock is 1, toBlock is 19, so it will return 3 that is bigger hat maxSize + testData.l2syncerMock.EXPECT().GetBridgesPublished(testData.ctx, fromBlock, toBlock-1).Return([]bridgesync.Bridge{ + {}, {}, {}, + }, nil).Once() + + // fromBlock is 1, toBlock is 18, so it will return 0. So must use previous one even that is > maxSize + testData.l2syncerMock.EXPECT().GetBridgesPublished(testData.ctx, fromBlock, toBlock-2).Return([]bridgesync.Bridge{}, nil).Once() + testData.l2syncerMock.EXPECT().GetClaims(testData.ctx, fromBlock, mock.Anything).Return([]bridgesync.Claim{}, nil) + newToBlock, _, _, err := testData.sut.limitCertSize(testData.ctx, fromBlock, toBlock) + require.NoError(t, err) + require.Equal(t, toBlock-1, newToBlock) +} + type testDataFlags = int const ( @@ -1977,6 +2034,9 @@ func newAggsenderTestData(t *testing.T, creationFlags testDataFlags) *aggsenderT aggLayerClient: agglayerClientMock, storage: storage, l1infoTreeSyncer: l1InfoTreeSyncerMock, + cfg: Config{ + MaxCertSize: 1024 * 1024, + }, } testCerts := []aggsendertypes.CertificateInfo{ { From 0612869cfcbb68edfe5d146ba6f28fa0f364126f Mon Sep 17 00:00:00 2001 From: joanestebanr <129153821+joanestebanr@users.noreply.github.com> Date: Tue, 3 Dec 2024 12:14:14 +0100 Subject: [PATCH 06/11] fix: PR comments --- aggsender/aggsender.go | 16 ++++++++++++++-- aggsender/aggsender_test.go | 26 ++++++++++++++++++++++++++ 2 files changed, 40 insertions(+), 2 deletions(-) diff --git a/aggsender/aggsender.go b/aggsender/aggsender.go index 7d262c97..9ee6e3cc 100644 --- a/aggsender/aggsender.go +++ b/aggsender/aggsender.go @@ -275,7 +275,10 @@ func (a *AggSender) limitCertSize(ctx context.Context, fromBlock, toBlock uint64 var err error var bridges, previousBridges []bridgesync.Bridge var claims, previousClaims []bridgesync.Claim - for true { + if toBlock < fromBlock { + return toBlock, nil, nil, fmt.Errorf("invalid call, toBlock(%d) Date: Tue, 3 Dec 2024 12:28:43 +0100 Subject: [PATCH 07/11] fix: lint --- aggsender/aggsender.go | 5 ++--- aggsender/aggsender_test.go | 14 ++++++-------- 2 files changed, 8 insertions(+), 11 deletions(-) diff --git a/aggsender/aggsender.go b/aggsender/aggsender.go index 9ee6e3cc..91190cb6 100644 --- a/aggsender/aggsender.go +++ b/aggsender/aggsender.go @@ -290,7 +290,7 @@ func (a *AggSender) limitCertSize(ctx context.Context, fromBlock, toBlock uint64 if len(bridges) == 0 { // We can't reduce more the certificate, so this is the minium size - a.log.Warnf("We reach the minium size of bridge: %d that is bigger than the max size of certificate: %d", + a.log.Warnf("We reach the minium size of bridge.Certificate size: %d >max size: %d", a.estimateSizeCert(len(previousBridges), len(previousClaims)), a.cfg.MaxCertSize) return toBlock + 1, previousBridges, previousClaims, nil } @@ -300,7 +300,7 @@ func (a *AggSender) limitCertSize(ctx context.Context, fromBlock, toBlock uint64 } // Minimum size of the certificate if fromBlock == toBlock { - a.log.Warnf("We reach the minium num blocks [%d to %d] of certificate: %d that is bigger than the max size of certificate: %d", + a.log.Warnf("reach the minium num blocks [%d to %d].Certificate size: %d >max size: %d", fromBlock, toBlock, a.estimateSizeCert(len(bridges), len(claims)), a.cfg.MaxCertSize) return toBlock, bridges, claims, nil } @@ -310,7 +310,6 @@ func (a *AggSender) limitCertSize(ctx context.Context, fromBlock, toBlock uint64 previousBridges = bridges previousClaims = claims } - return 0, nil, nil, fmt.Errorf("error reducing the size of the certificate") } func (a *AggSender) estimateSizeCert(numBridges, numClaims int) uint { diff --git a/aggsender/aggsender_test.go b/aggsender/aggsender_test.go index 02ce1b76..a54853ad 100644 --- a/aggsender/aggsender_test.go +++ b/aggsender/aggsender_test.go @@ -1974,28 +1974,26 @@ func TestLimitSize_NoWayToFitInMaxSize(t *testing.T) { func TestLimitSize_InvalidCall(t *testing.T) { testData := newAggsenderTestData(t, testDataFlagMockStorage) - _, _, _, err := testData.sut.limitCertSize(testData.ctx, 10, 5) + _, _, _, err := testData.sut.limitCertSize(testData.ctx, 10, 5) //nolint: dogsled require.Error(t, err) } func TestLimitSize_MinNumBlocks(t *testing.T) { testData := newAggsenderTestData(t, testDataFlagMockStorage) testData.sut.cfg.MaxCertSize = (estimatedSizeBridgeExit * 2) + 1 - fromBlock := uint64(1) - toBlock := uint64(2) // It returns 4 bridge - testData.l2syncerMock.EXPECT().GetBridgesPublished(testData.ctx, fromBlock, toBlock).Return([]bridgesync.Bridge{ + testData.l2syncerMock.EXPECT().GetBridgesPublished(testData.ctx, uint64(1), uint64(2)).Return([]bridgesync.Bridge{ {}, {}, {}, {}, }, nil).Once() // fromBlock is 1, toBlock is 19, so it will return 3 that is bigger hat maxSize - testData.l2syncerMock.EXPECT().GetBridgesPublished(testData.ctx, fromBlock, toBlock-1).Return([]bridgesync.Bridge{ + testData.l2syncerMock.EXPECT().GetBridgesPublished(testData.ctx, uint64(1), uint64(1)).Return([]bridgesync.Bridge{ {}, {}, {}, }, nil).Once() - testData.l2syncerMock.EXPECT().GetClaims(testData.ctx, fromBlock, mock.Anything).Return([]bridgesync.Claim{}, nil) - newToBlock, _, _, err := testData.sut.limitCertSize(testData.ctx, fromBlock, toBlock) + testData.l2syncerMock.EXPECT().GetClaims(testData.ctx, uint64(1), mock.Anything).Return([]bridgesync.Claim{}, nil) + newToBlock, _, _, err := testData.sut.limitCertSize(testData.ctx, 1, 2) require.NoError(t, err) - require.Equal(t, toBlock-1, newToBlock) + require.Equal(t, uint64(1), newToBlock) } type testDataFlags = int From 12c65611f61bb0dfc973e36dd651001c25549c86 Mon Sep 17 00:00:00 2001 From: joanestebanr <129153821+joanestebanr@users.noreply.github.com> Date: Tue, 3 Dec 2024 13:56:00 +0100 Subject: [PATCH 08/11] feat: PR comment, refactor limitCertSize --- aggsender/aggsender.go | 94 ++++++++----------- aggsender/aggsender_test.go | 125 +++++++++++++------------- aggsender/types/certificate_params.go | 92 +++++++++++++++++++ 3 files changed, 194 insertions(+), 117 deletions(-) create mode 100644 aggsender/types/certificate_params.go diff --git a/aggsender/aggsender.go b/aggsender/aggsender.go index 91190cb6..cfc610ea 100644 --- a/aggsender/aggsender.go +++ b/aggsender/aggsender.go @@ -187,14 +187,25 @@ func (a *AggSender) sendCertificate(ctx context.Context) (*agglayer.SignedCertif return nil, nil } - toBlock, bridges, claims, err := a.limitCertSize(ctx, fromBlock, toBlock) + claims, err := a.l2Syncer.GetClaims(ctx, fromBlock, toBlock) + if err != nil { + return nil, fmt.Errorf("error getting claims: %w", err) + } + certificateParams := &types.CertificateLocalParams{ + FromBlock: fromBlock, + ToBlock: toBlock, + Bridges: bridges, + Claims: claims, + } + + certificateParams, err = a.limitCertSize(certificateParams) if err != nil { return nil, fmt.Errorf("error limitCertSize: %w", err) } - a.log.Infof("building certificate for block: %d to block: %d, numBridges=%d, numClaims=%d estimatedSize=%d", - fromBlock, toBlock, len(bridges), len(claims), a.estimateSizeCert(len(bridges), len(claims))) + a.log.Infof("building certificate for %s estimatedSize=%d", + certificateParams.String(), certificateParams.EstimatedSize()) - certificate, err := a.buildCertificate(ctx, bridges, claims, lastSentCertificateInfo, toBlock) + certificate, err := a.buildCertificate(ctx, certificateParams, lastSentCertificateInfo) if err != nil { return nil, fmt.Errorf("error building certificate: %w", err) } @@ -265,57 +276,36 @@ func (a *AggSender) saveCertificateToStorage(ctx context.Context, cert types.Cer return nil } -const ( - estimatedSizeBridgeExit = 250 - estimatedSizeClaim = 44000 -) - -func (a *AggSender) limitCertSize(ctx context.Context, fromBlock, toBlock uint64) (uint64, - []bridgesync.Bridge, []bridgesync.Claim, error) { +func (a *AggSender) limitCertSize(fullCert *types.CertificateLocalParams) (*types.CertificateLocalParams, error) { + currentCert := fullCert + var previousCert *types.CertificateLocalParams var err error - var bridges, previousBridges []bridgesync.Bridge - var claims, previousClaims []bridgesync.Claim - if toBlock < fromBlock { - return toBlock, nil, nil, fmt.Errorf("invalid call, toBlock(%d)max size: %d", - a.estimateSizeCert(len(previousBridges), len(previousClaims)), a.cfg.MaxCertSize) - return toBlock + 1, previousBridges, previousClaims, nil + previousCert.EstimatedSize(), a.cfg.MaxCertSize) + return previousCert, nil } - if a.cfg.MaxCertSize == 0 || a.estimateSizeCert(len(bridges), len(claims)) < a.cfg.MaxCertSize { - return toBlock, bridges, claims, nil + if a.cfg.MaxCertSize == 0 || currentCert.EstimatedSize() < a.cfg.MaxCertSize { + return currentCert, nil } + // Minimum size of the certificate - if fromBlock == toBlock { + if currentCert.NumberOfBlocks() <= 1 { a.log.Warnf("reach the minium num blocks [%d to %d].Certificate size: %d >max size: %d", - fromBlock, toBlock, a.estimateSizeCert(len(bridges), len(claims)), a.cfg.MaxCertSize) - return toBlock, bridges, claims, nil + currentCert.FromBlock, currentCert.ToBlock, currentCert.EstimatedSize(), a.cfg.MaxCertSize) + return currentCert, nil + } + previousCert = currentCert + currentCert, err = currentCert.Range(currentCert.FromBlock, currentCert.ToBlock-1) + if err != nil { + return nil, fmt.Errorf("error reducing certificate: %w", err) } - - // We have to reduce the number of blocks - toBlock-- - previousBridges = bridges - previousClaims = claims } } -func (a *AggSender) estimateSizeCert(numBridges, numClaims int) uint { - return uint(numBridges*estimatedSizeBridgeExit + numClaims*estimatedSizeClaim) -} - // saveCertificate saves the certificate to a tmp file func (a *AggSender) saveCertificateToFile(signedCertificate *agglayer.SignedCertificate) { if signedCertificate == nil || a.cfg.SaveCertificatesToFilesPath == "" { @@ -380,25 +370,19 @@ func (a *AggSender) getNextHeightAndPreviousLER( // buildCertificate builds a certificate from the bridge events func (a *AggSender) buildCertificate(ctx context.Context, - bridges []bridgesync.Bridge, - claims []bridgesync.Claim, - lastSentCertificateInfo *types.CertificateInfo, - toBlock uint64) (*agglayer.Certificate, error) { - if len(bridges) == 0 && len(claims) == 0 { + certParams *types.CertificateLocalParams, + lastSentCertificateInfo *types.CertificateInfo) (*agglayer.Certificate, error) { + if certParams.IsEmpty() { return nil, errNoBridgesAndClaims } - bridgeExits := a.getBridgeExits(bridges) - importedBridgeExits, err := a.getImportedBridgeExits(ctx, claims) + bridgeExits := a.getBridgeExits(certParams.Bridges) + importedBridgeExits, err := a.getImportedBridgeExits(ctx, certParams.Claims) if err != nil { return nil, fmt.Errorf("error getting imported bridge exits: %w", err) } - var depositCount uint32 - - if len(bridges) > 0 { - depositCount = bridges[len(bridges)-1].DepositCount - } + depositCount := certParams.MaxDepoitCount() exitRoot, err := a.l2Syncer.GetExitRootByIndex(ctx, depositCount) if err != nil { @@ -417,7 +401,7 @@ func (a *AggSender) buildCertificate(ctx context.Context, BridgeExits: bridgeExits, ImportedBridgeExits: importedBridgeExits, Height: height, - Metadata: createCertificateMetadata(toBlock), + Metadata: createCertificateMetadata(certParams.ToBlock), }, nil } diff --git a/aggsender/aggsender_test.go b/aggsender/aggsender_test.go index a54853ad..f9495b99 100644 --- a/aggsender/aggsender_test.go +++ b/aggsender/aggsender_test.go @@ -787,7 +787,13 @@ func TestBuildCertificate(t *testing.T) { l1infoTreeSyncer: mockL1InfoTreeSyncer, log: log.WithFields("test", "unittest"), } - cert, err := aggSender.buildCertificate(context.Background(), tt.bridges, tt.claims, &tt.lastSentCertificateInfo, tt.toBlock) + + certParam := &aggsendertypes.CertificateLocalParams{ + ToBlock: tt.toBlock, + Bridges: tt.bridges, + Claims: tt.claims, + } + cert, err := aggSender.buildCertificate(context.Background(), certParam, &tt.lastSentCertificateInfo) if tt.expectedError { require.Error(t, err) @@ -1917,83 +1923,53 @@ func TestCheckLastCertificateFromAgglayer_Case4ErrorUpdateStatus(t *testing.T) { func TestLimitSize_FirstOneFit(t *testing.T) { testData := newAggsenderTestData(t, testDataFlagMockStorage) - fromBlock := uint64(1) - toBlock := uint64(20) - // It returns 1 bridge - testData.l2syncerMock.EXPECT().GetBridgesPublished(testData.ctx, fromBlock, toBlock).Return([]bridgesync.Bridge{ - {}, - }, nil) - testData.l2syncerMock.EXPECT().GetClaims(testData.ctx, fromBlock, toBlock).Return([]bridgesync.Claim{}, nil) - newToBlock, _, _, err := testData.sut.limitCertSize(testData.ctx, fromBlock, toBlock) + certParams := &aggsendertypes.CertificateLocalParams{ + FromBlock: uint64(1), + ToBlock: uint64(20), + Bridges: NewBridgesData(1, []uint64{1}), + } + newCert, err := testData.sut.limitCertSize(certParams) require.NoError(t, err) - require.Equal(t, toBlock, newToBlock) + require.Equal(t, certParams, newCert) } func TestLimitSize_FirstMinusOneFit(t *testing.T) { testData := newAggsenderTestData(t, testDataFlagMockStorage) - testData.sut.cfg.MaxCertSize = (estimatedSizeBridgeExit * 3) + 1 - fromBlock := uint64(1) - toBlock := uint64(20) - // It returns 4 bridge - testData.l2syncerMock.EXPECT().GetBridgesPublished(testData.ctx, fromBlock, toBlock).Return([]bridgesync.Bridge{ - {}, {}, {}, {}, - }, nil).Once() - - // fromBlock is 1, toBlock is 20, so it will return 3 - testData.l2syncerMock.EXPECT().GetBridgesPublished(testData.ctx, fromBlock, toBlock-1).Return([]bridgesync.Bridge{ - {}, {}, {}, - }, nil).Once() - testData.l2syncerMock.EXPECT().GetClaims(testData.ctx, fromBlock, mock.Anything).Return([]bridgesync.Claim{}, nil) - newToBlock, _, _, err := testData.sut.limitCertSize(testData.ctx, fromBlock, toBlock) + testData.sut.cfg.MaxCertSize = (aggsendertypes.EstimatedSizeBridgeExit * 3) + 1 + certParams := &aggsendertypes.CertificateLocalParams{ + FromBlock: uint64(1), + ToBlock: uint64(20), + Bridges: NewBridgesData(4, []uint64{19, 19, 19, 20}), + } + newCert, err := testData.sut.limitCertSize(certParams) require.NoError(t, err) - require.Equal(t, toBlock-1, newToBlock) + require.Equal(t, uint64(19), newCert.ToBlock) } func TestLimitSize_NoWayToFitInMaxSize(t *testing.T) { testData := newAggsenderTestData(t, testDataFlagMockStorage) - testData.sut.cfg.MaxCertSize = (estimatedSizeBridgeExit * 2) + 1 - fromBlock := uint64(1) - toBlock := uint64(20) - // It returns 4 bridge - testData.l2syncerMock.EXPECT().GetBridgesPublished(testData.ctx, fromBlock, toBlock).Return([]bridgesync.Bridge{ - {}, {}, {}, {}, - }, nil).Once() - - // fromBlock is 1, toBlock is 19, so it will return 3 that is bigger hat maxSize - testData.l2syncerMock.EXPECT().GetBridgesPublished(testData.ctx, fromBlock, toBlock-1).Return([]bridgesync.Bridge{ - {}, {}, {}, - }, nil).Once() - - // fromBlock is 1, toBlock is 18, so it will return 0. So must use previous one even that is > maxSize - testData.l2syncerMock.EXPECT().GetBridgesPublished(testData.ctx, fromBlock, toBlock-2).Return([]bridgesync.Bridge{}, nil).Once() - testData.l2syncerMock.EXPECT().GetClaims(testData.ctx, fromBlock, mock.Anything).Return([]bridgesync.Claim{}, nil) - newToBlock, _, _, err := testData.sut.limitCertSize(testData.ctx, fromBlock, toBlock) + testData.sut.cfg.MaxCertSize = (aggsendertypes.EstimatedSizeBridgeExit * 2) + 1 + certParams := &aggsendertypes.CertificateLocalParams{ + FromBlock: uint64(1), + ToBlock: uint64(20), + Bridges: NewBridgesData(4, []uint64{19, 19, 19, 20}), + } + newCert, err := testData.sut.limitCertSize(certParams) require.NoError(t, err) - require.Equal(t, toBlock-1, newToBlock) -} - -func TestLimitSize_InvalidCall(t *testing.T) { - testData := newAggsenderTestData(t, testDataFlagMockStorage) - _, _, _, err := testData.sut.limitCertSize(testData.ctx, 10, 5) //nolint: dogsled - require.Error(t, err) + require.Equal(t, uint64(19), newCert.ToBlock) } func TestLimitSize_MinNumBlocks(t *testing.T) { testData := newAggsenderTestData(t, testDataFlagMockStorage) - testData.sut.cfg.MaxCertSize = (estimatedSizeBridgeExit * 2) + 1 - // It returns 4 bridge - testData.l2syncerMock.EXPECT().GetBridgesPublished(testData.ctx, uint64(1), uint64(2)).Return([]bridgesync.Bridge{ - {}, {}, {}, {}, - }, nil).Once() - - // fromBlock is 1, toBlock is 19, so it will return 3 that is bigger hat maxSize - testData.l2syncerMock.EXPECT().GetBridgesPublished(testData.ctx, uint64(1), uint64(1)).Return([]bridgesync.Bridge{ - {}, {}, {}, - }, nil).Once() - testData.l2syncerMock.EXPECT().GetClaims(testData.ctx, uint64(1), mock.Anything).Return([]bridgesync.Claim{}, nil) - newToBlock, _, _, err := testData.sut.limitCertSize(testData.ctx, 1, 2) + testData.sut.cfg.MaxCertSize = (aggsendertypes.EstimatedSizeBridgeExit * 2) + 1 + certParams := &aggsendertypes.CertificateLocalParams{ + FromBlock: uint64(1), + ToBlock: uint64(2), + Bridges: NewBridgesData(6, []uint64{1, 1, 1, 2, 2, 2}), + } + newCert, err := testData.sut.limitCertSize(certParams) require.NoError(t, err) - require.Equal(t, uint64(1), newToBlock) + require.Equal(t, uint64(1), newCert.ToBlock) } type testDataFlags = int @@ -2013,6 +1989,31 @@ type aggsenderTestData struct { testCerts []aggsendertypes.CertificateInfo } +func NewBridgesData(num int, blockNum []uint64) []bridgesync.Bridge { + res := make([]bridgesync.Bridge, 0) + for i := 0; i < num; i++ { + res = append(res, bridgesync.Bridge{ + BlockNum: blockNum[i%len(blockNum)], + BlockPos: 0, + LeafType: agglayer.LeafTypeAsset.Uint8(), + OriginNetwork: 1, + }) + } + return res +} + +func NewClaimData(num int, blockNum []uint64) []bridgesync.Claim { + res := make([]bridgesync.Claim, 0) + for i := 0; i < num; i++ { + res = append(res, bridgesync.Claim{ + BlockNum: blockNum[i%len(blockNum)], + BlockPos: 0, + }) + } + return res + +} + func certInfoToCertHeader(certInfo *aggsendertypes.CertificateInfo, networkID uint32) *agglayer.CertificateHeader { if certInfo == nil { return nil diff --git a/aggsender/types/certificate_params.go b/aggsender/types/certificate_params.go new file mode 100644 index 00000000..bb118e88 --- /dev/null +++ b/aggsender/types/certificate_params.go @@ -0,0 +1,92 @@ +package types + +import ( + "fmt" + + "github.com/0xPolygon/cdk/bridgesync" +) + +const ( + EstimatedSizeBridgeExit = 250 + EstimatedSizeClaim = 44000 +) + +type CertificateLocalParams struct { + FromBlock uint64 + ToBlock uint64 + Bridges []bridgesync.Bridge + Claims []bridgesync.Claim +} + +func (c *CertificateLocalParams) String() string { + return fmt.Sprintf("FromBlock: %d, ToBlock: %d, numBridges: %d, numClaims: %d", c.FromBlock, c.ToBlock, c.NumberOfBridges(), c.NumberOfClaims()) +} + +func (c *CertificateLocalParams) Range(fromBlock, toBlock uint64) (*CertificateLocalParams, error) { + if c.FromBlock == fromBlock && c.ToBlock == toBlock { + return c, nil + } + if c.FromBlock > fromBlock || c.ToBlock < toBlock { + return nil, fmt.Errorf("invalid range") + } + newCert := &CertificateLocalParams{ + FromBlock: fromBlock, + ToBlock: toBlock, + Bridges: make([]bridgesync.Bridge, 0), + Claims: make([]bridgesync.Claim, 0), + } + + for _, bridge := range c.Bridges { + if bridge.BlockNum >= fromBlock && bridge.BlockNum <= toBlock { + newCert.Bridges = append(newCert.Bridges, bridge) + } + } + + for _, claim := range c.Claims { + if claim.BlockNum >= fromBlock && claim.BlockNum <= toBlock { + newCert.Claims = append(newCert.Claims, claim) + } + } + return newCert, nil +} + +func (c *CertificateLocalParams) NumberOfBridges() int { + if c == nil { + return 0 + } + return len(c.Bridges) +} + +func (c *CertificateLocalParams) NumberOfClaims() int { + if c == nil { + return 0 + } + return len(c.Claims) +} + +func (c *CertificateLocalParams) NumberOfBlocks() int { + if c == nil { + return 0 + } + return int(c.ToBlock - c.FromBlock + 1) +} + +func (c *CertificateLocalParams) EstimatedSize() uint { + if c == nil { + return 0 + } + numBridges := len(c.Bridges) + numClaims := len(c.Claims) + return uint(numBridges*EstimatedSizeBridgeExit + numClaims*EstimatedSizeClaim) +} + +func (c *CertificateLocalParams) IsEmpty() bool { + return c.NumberOfBridges() == 0 && c.NumberOfClaims() == 0 +} + +func (c *CertificateLocalParams) MaxDepoitCount() uint32 { + if c == nil || c.NumberOfBridges() == 0 { + return 0 + } + return c.Bridges[len(c.Bridges)-1].DepositCount +} From 2409540da291a20af730779f850cc6333547342c Mon Sep 17 00:00:00 2001 From: joanestebanr <129153821+joanestebanr@users.noreply.github.com> Date: Tue, 3 Dec 2024 14:14:17 +0100 Subject: [PATCH 09/11] fix: lint --- aggsender/aggsender_test.go | 1 - aggsender/types/certificate_params.go | 3 ++- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/aggsender/aggsender_test.go b/aggsender/aggsender_test.go index f9495b99..4b5be9ca 100644 --- a/aggsender/aggsender_test.go +++ b/aggsender/aggsender_test.go @@ -2011,7 +2011,6 @@ func NewClaimData(num int, blockNum []uint64) []bridgesync.Claim { }) } return res - } func certInfoToCertHeader(certInfo *aggsendertypes.CertificateInfo, networkID uint32) *agglayer.CertificateHeader { diff --git a/aggsender/types/certificate_params.go b/aggsender/types/certificate_params.go index bb118e88..2b918f9c 100644 --- a/aggsender/types/certificate_params.go +++ b/aggsender/types/certificate_params.go @@ -19,7 +19,8 @@ type CertificateLocalParams struct { } func (c *CertificateLocalParams) String() string { - return fmt.Sprintf("FromBlock: %d, ToBlock: %d, numBridges: %d, numClaims: %d", c.FromBlock, c.ToBlock, c.NumberOfBridges(), c.NumberOfClaims()) + return fmt.Sprintf("FromBlock: %d, ToBlock: %d, numBridges: %d, numClaims: %d", + c.FromBlock, c.ToBlock, c.NumberOfBridges(), c.NumberOfClaims()) } func (c *CertificateLocalParams) Range(fromBlock, toBlock uint64) (*CertificateLocalParams, error) { From 7439201c53cd7419fbfd1c1ea112eb13e3eba348 Mon Sep 17 00:00:00 2001 From: joanestebanr <129153821+joanestebanr@users.noreply.github.com> Date: Tue, 3 Dec 2024 14:26:19 +0100 Subject: [PATCH 10/11] fix: update PR comments --- aggsender/aggsender.go | 8 +-- aggsender/aggsender_test.go | 49 ++++++++------ aggsender/types/certificate_params.go | 93 --------------------------- 3 files changed, 33 insertions(+), 117 deletions(-) delete mode 100644 aggsender/types/certificate_params.go diff --git a/aggsender/aggsender.go b/aggsender/aggsender.go index cfc610ea..d40ed7a7 100644 --- a/aggsender/aggsender.go +++ b/aggsender/aggsender.go @@ -191,7 +191,7 @@ func (a *AggSender) sendCertificate(ctx context.Context) (*agglayer.SignedCertif if err != nil { return nil, fmt.Errorf("error getting claims: %w", err) } - certificateParams := &types.CertificateLocalParams{ + certificateParams := &types.CertificateBuildParams{ FromBlock: fromBlock, ToBlock: toBlock, Bridges: bridges, @@ -276,9 +276,9 @@ func (a *AggSender) saveCertificateToStorage(ctx context.Context, cert types.Cer return nil } -func (a *AggSender) limitCertSize(fullCert *types.CertificateLocalParams) (*types.CertificateLocalParams, error) { +func (a *AggSender) limitCertSize(fullCert *types.CertificateBuildParams) (*types.CertificateBuildParams, error) { currentCert := fullCert - var previousCert *types.CertificateLocalParams + var previousCert *types.CertificateBuildParams var err error for { if currentCert.NumberOfBridges() == 0 { @@ -370,7 +370,7 @@ func (a *AggSender) getNextHeightAndPreviousLER( // buildCertificate builds a certificate from the bridge events func (a *AggSender) buildCertificate(ctx context.Context, - certParams *types.CertificateLocalParams, + certParams *types.CertificateBuildParams, lastSentCertificateInfo *types.CertificateInfo) (*agglayer.Certificate, error) { if certParams.IsEmpty() { return nil, errNoBridgesAndClaims diff --git a/aggsender/aggsender_test.go b/aggsender/aggsender_test.go index 4b5be9ca..2228ea26 100644 --- a/aggsender/aggsender_test.go +++ b/aggsender/aggsender_test.go @@ -788,7 +788,7 @@ func TestBuildCertificate(t *testing.T) { log: log.WithFields("test", "unittest"), } - certParam := &aggsendertypes.CertificateLocalParams{ + certParam := &aggsendertypes.CertificateBuildParams{ ToBlock: tt.toBlock, Bridges: tt.bridges, Claims: tt.claims, @@ -1799,7 +1799,7 @@ func TestCheckLastCertificateFromAgglayer_Case2NoCertLocalCertRemote(t *testing. testData := newAggsenderTestData(t, testDataFlagNone) testData.l2syncerMock.EXPECT().OriginNetwork().Return(networkIDTest).Once() testData.agglayerClientMock.EXPECT().GetLatestKnownCertificateHeader(networkIDTest). - Return(certInfoToCertHeader(&testData.testCerts[0], networkIDTest), nil).Once() + Return(certInfoToCertHeader(t, &testData.testCerts[0], networkIDTest), nil).Once() err := testData.sut.checkLastCertificateFromAgglayer(testData.ctx) @@ -1815,7 +1815,7 @@ func TestCheckLastCertificateFromAgglayer_Case2NoCertLocalCertRemoteErrorStorage testData := newAggsenderTestData(t, testDataFlagMockStorage) testData.l2syncerMock.EXPECT().OriginNetwork().Return(networkIDTest).Once() testData.agglayerClientMock.EXPECT().GetLatestKnownCertificateHeader(networkIDTest). - Return(certInfoToCertHeader(&testData.testCerts[0], networkIDTest), nil).Once() + Return(certInfoToCertHeader(t, &testData.testCerts[0], networkIDTest), nil).Once() testData.storageMock.EXPECT().GetLastSentCertificate().Return(nil, nil) testData.storageMock.EXPECT().SaveLastSentCertificate(mock.Anything, mock.Anything).Return(errTest).Once() err := testData.sut.checkLastCertificateFromAgglayer(testData.ctx) @@ -1841,7 +1841,7 @@ func TestCheckLastCertificateFromAgglayer_Case3_1LessHeight(t *testing.T) { testData := newAggsenderTestData(t, testDataFlagMockStorage) testData.l2syncerMock.EXPECT().OriginNetwork().Return(networkIDTest).Once() testData.agglayerClientMock.EXPECT().GetLatestKnownCertificateHeader(networkIDTest). - Return(certInfoToCertHeader(&testData.testCerts[0], networkIDTest), nil).Once() + Return(certInfoToCertHeader(t, &testData.testCerts[0], networkIDTest), nil).Once() testData.storageMock.EXPECT().GetLastSentCertificate().Return(&testData.testCerts[1], nil) err := testData.sut.checkLastCertificateFromAgglayer(testData.ctx) @@ -1854,7 +1854,7 @@ func TestCheckLastCertificateFromAgglayer_Case3_2Mismatch(t *testing.T) { testData := newAggsenderTestData(t, testDataFlagMockStorage) testData.l2syncerMock.EXPECT().OriginNetwork().Return(networkIDTest).Once() testData.agglayerClientMock.EXPECT().GetLatestKnownCertificateHeader(networkIDTest). - Return(certInfoToCertHeader(&testData.testCerts[1], networkIDTest), nil).Once() + Return(certInfoToCertHeader(t, &testData.testCerts[1], networkIDTest), nil).Once() testData.storageMock.EXPECT().GetLastSentCertificate().Return(&testData.testCerts[0], nil) testData.storageMock.EXPECT().SaveLastSentCertificate(mock.Anything, mock.Anything).Return(nil).Once() @@ -1868,7 +1868,7 @@ func TestCheckLastCertificateFromAgglayer_Case4Mismatch(t *testing.T) { testData := newAggsenderTestData(t, testDataFlagMockStorage) testData.l2syncerMock.EXPECT().OriginNetwork().Return(networkIDTest).Once() testData.agglayerClientMock.EXPECT().GetLatestKnownCertificateHeader(networkIDTest). - Return(certInfoToCertHeader(&testData.testCerts[0], networkIDTest), nil).Once() + Return(certInfoToCertHeader(t, &testData.testCerts[0], networkIDTest), nil).Once() testData.storageMock.EXPECT().GetLastSentCertificate().Return(&testData.testCerts[1], nil) err := testData.sut.checkLastCertificateFromAgglayer(testData.ctx) @@ -1881,7 +1881,7 @@ func TestCheckLastCertificateFromAgglayer_Case5SameStatus(t *testing.T) { testData := newAggsenderTestData(t, testDataFlagMockStorage) testData.l2syncerMock.EXPECT().OriginNetwork().Return(networkIDTest).Once() testData.agglayerClientMock.EXPECT().GetLatestKnownCertificateHeader(networkIDTest). - Return(certInfoToCertHeader(&testData.testCerts[0], networkIDTest), nil).Once() + Return(certInfoToCertHeader(t, &testData.testCerts[0], networkIDTest), nil).Once() testData.storageMock.EXPECT().GetLastSentCertificate().Return(&testData.testCerts[0], nil) err := testData.sut.checkLastCertificateFromAgglayer(testData.ctx) @@ -1893,7 +1893,7 @@ func TestCheckLastCertificateFromAgglayer_Case5SameStatus(t *testing.T) { func TestCheckLastCertificateFromAgglayer_Case5UpdateStatus(t *testing.T) { testData := newAggsenderTestData(t, testDataFlagMockStorage) testData.l2syncerMock.EXPECT().OriginNetwork().Return(networkIDTest).Once() - aggLayerCert := certInfoToCertHeader(&testData.testCerts[0], networkIDTest) + aggLayerCert := certInfoToCertHeader(t, &testData.testCerts[0], networkIDTest) aggLayerCert.Status = agglayer.Settled testData.agglayerClientMock.EXPECT().GetLatestKnownCertificateHeader(networkIDTest). Return(aggLayerCert, nil).Once() @@ -1909,7 +1909,7 @@ func TestCheckLastCertificateFromAgglayer_Case5UpdateStatus(t *testing.T) { func TestCheckLastCertificateFromAgglayer_Case4ErrorUpdateStatus(t *testing.T) { testData := newAggsenderTestData(t, testDataFlagMockStorage) testData.l2syncerMock.EXPECT().OriginNetwork().Return(networkIDTest).Once() - aggLayerCert := certInfoToCertHeader(&testData.testCerts[0], networkIDTest) + aggLayerCert := certInfoToCertHeader(t, &testData.testCerts[0], networkIDTest) aggLayerCert.Status = agglayer.Settled testData.agglayerClientMock.EXPECT().GetLatestKnownCertificateHeader(networkIDTest). Return(aggLayerCert, nil).Once() @@ -1923,10 +1923,10 @@ func TestCheckLastCertificateFromAgglayer_Case4ErrorUpdateStatus(t *testing.T) { func TestLimitSize_FirstOneFit(t *testing.T) { testData := newAggsenderTestData(t, testDataFlagMockStorage) - certParams := &aggsendertypes.CertificateLocalParams{ + certParams := &aggsendertypes.CertificateBuildParams{ FromBlock: uint64(1), ToBlock: uint64(20), - Bridges: NewBridgesData(1, []uint64{1}), + Bridges: NewBridgesData(t, 1, []uint64{1}), } newCert, err := testData.sut.limitCertSize(certParams) require.NoError(t, err) @@ -1936,10 +1936,10 @@ func TestLimitSize_FirstOneFit(t *testing.T) { func TestLimitSize_FirstMinusOneFit(t *testing.T) { testData := newAggsenderTestData(t, testDataFlagMockStorage) testData.sut.cfg.MaxCertSize = (aggsendertypes.EstimatedSizeBridgeExit * 3) + 1 - certParams := &aggsendertypes.CertificateLocalParams{ + certParams := &aggsendertypes.CertificateBuildParams{ FromBlock: uint64(1), ToBlock: uint64(20), - Bridges: NewBridgesData(4, []uint64{19, 19, 19, 20}), + Bridges: NewBridgesData(t, 0, []uint64{19, 19, 19, 20}), } newCert, err := testData.sut.limitCertSize(certParams) require.NoError(t, err) @@ -1949,10 +1949,10 @@ func TestLimitSize_FirstMinusOneFit(t *testing.T) { func TestLimitSize_NoWayToFitInMaxSize(t *testing.T) { testData := newAggsenderTestData(t, testDataFlagMockStorage) testData.sut.cfg.MaxCertSize = (aggsendertypes.EstimatedSizeBridgeExit * 2) + 1 - certParams := &aggsendertypes.CertificateLocalParams{ + certParams := &aggsendertypes.CertificateBuildParams{ FromBlock: uint64(1), ToBlock: uint64(20), - Bridges: NewBridgesData(4, []uint64{19, 19, 19, 20}), + Bridges: NewBridgesData(t, 0, []uint64{19, 19, 19, 20}), } newCert, err := testData.sut.limitCertSize(certParams) require.NoError(t, err) @@ -1962,10 +1962,10 @@ func TestLimitSize_NoWayToFitInMaxSize(t *testing.T) { func TestLimitSize_MinNumBlocks(t *testing.T) { testData := newAggsenderTestData(t, testDataFlagMockStorage) testData.sut.cfg.MaxCertSize = (aggsendertypes.EstimatedSizeBridgeExit * 2) + 1 - certParams := &aggsendertypes.CertificateLocalParams{ + certParams := &aggsendertypes.CertificateBuildParams{ FromBlock: uint64(1), ToBlock: uint64(2), - Bridges: NewBridgesData(6, []uint64{1, 1, 1, 2, 2, 2}), + Bridges: NewBridgesData(t, 0, []uint64{1, 1, 1, 2, 2, 2}), } newCert, err := testData.sut.limitCertSize(certParams) require.NoError(t, err) @@ -1989,7 +1989,11 @@ type aggsenderTestData struct { testCerts []aggsendertypes.CertificateInfo } -func NewBridgesData(num int, blockNum []uint64) []bridgesync.Bridge { +func NewBridgesData(t *testing.T, num int, blockNum []uint64) []bridgesync.Bridge { + t.Helper() + if num == 0 { + num = len(blockNum) + } res := make([]bridgesync.Bridge, 0) for i := 0; i < num; i++ { res = append(res, bridgesync.Bridge{ @@ -2002,7 +2006,11 @@ func NewBridgesData(num int, blockNum []uint64) []bridgesync.Bridge { return res } -func NewClaimData(num int, blockNum []uint64) []bridgesync.Claim { +func NewClaimData(t *testing.T, num int, blockNum []uint64) []bridgesync.Claim { + t.Helper() + if num == 0 { + num = len(blockNum) + } res := make([]bridgesync.Claim, 0) for i := 0; i < num; i++ { res = append(res, bridgesync.Claim{ @@ -2013,7 +2021,8 @@ func NewClaimData(num int, blockNum []uint64) []bridgesync.Claim { return res } -func certInfoToCertHeader(certInfo *aggsendertypes.CertificateInfo, networkID uint32) *agglayer.CertificateHeader { +func certInfoToCertHeader(t *testing.T, certInfo *aggsendertypes.CertificateInfo, networkID uint32) *agglayer.CertificateHeader { + t.Helper() if certInfo == nil { return nil } diff --git a/aggsender/types/certificate_params.go b/aggsender/types/certificate_params.go deleted file mode 100644 index 2b918f9c..00000000 --- a/aggsender/types/certificate_params.go +++ /dev/null @@ -1,93 +0,0 @@ -package types - -import ( - "fmt" - - "github.com/0xPolygon/cdk/bridgesync" -) - -const ( - EstimatedSizeBridgeExit = 250 - EstimatedSizeClaim = 44000 -) - -type CertificateLocalParams struct { - FromBlock uint64 - ToBlock uint64 - Bridges []bridgesync.Bridge - Claims []bridgesync.Claim -} - -func (c *CertificateLocalParams) String() string { - return fmt.Sprintf("FromBlock: %d, ToBlock: %d, numBridges: %d, numClaims: %d", - c.FromBlock, c.ToBlock, c.NumberOfBridges(), c.NumberOfClaims()) -} - -func (c *CertificateLocalParams) Range(fromBlock, toBlock uint64) (*CertificateLocalParams, error) { - if c.FromBlock == fromBlock && c.ToBlock == toBlock { - return c, nil - } - if c.FromBlock > fromBlock || c.ToBlock < toBlock { - return nil, fmt.Errorf("invalid range") - } - newCert := &CertificateLocalParams{ - FromBlock: fromBlock, - ToBlock: toBlock, - Bridges: make([]bridgesync.Bridge, 0), - Claims: make([]bridgesync.Claim, 0), - } - - for _, bridge := range c.Bridges { - if bridge.BlockNum >= fromBlock && bridge.BlockNum <= toBlock { - newCert.Bridges = append(newCert.Bridges, bridge) - } - } - - for _, claim := range c.Claims { - if claim.BlockNum >= fromBlock && claim.BlockNum <= toBlock { - newCert.Claims = append(newCert.Claims, claim) - } - } - return newCert, nil -} - -func (c *CertificateLocalParams) NumberOfBridges() int { - if c == nil { - return 0 - } - return len(c.Bridges) -} - -func (c *CertificateLocalParams) NumberOfClaims() int { - if c == nil { - return 0 - } - return len(c.Claims) -} - -func (c *CertificateLocalParams) NumberOfBlocks() int { - if c == nil { - return 0 - } - return int(c.ToBlock - c.FromBlock + 1) -} - -func (c *CertificateLocalParams) EstimatedSize() uint { - if c == nil { - return 0 - } - numBridges := len(c.Bridges) - numClaims := len(c.Claims) - return uint(numBridges*EstimatedSizeBridgeExit + numClaims*EstimatedSizeClaim) -} - -func (c *CertificateLocalParams) IsEmpty() bool { - return c.NumberOfBridges() == 0 && c.NumberOfClaims() == 0 -} - -func (c *CertificateLocalParams) MaxDepoitCount() uint32 { - if c == nil || c.NumberOfBridges() == 0 { - return 0 - } - return c.Bridges[len(c.Bridges)-1].DepositCount -} From f5142cf11708693bdcb33532f9292003f671739b Mon Sep 17 00:00:00 2001 From: joanestebanr <129153821+joanestebanr@users.noreply.github.com> Date: Tue, 3 Dec 2024 14:39:36 +0100 Subject: [PATCH 11/11] feat: file renamed --- aggsender/types/certificate_build_params.go | 101 ++++++++++++++++++++ 1 file changed, 101 insertions(+) create mode 100644 aggsender/types/certificate_build_params.go diff --git a/aggsender/types/certificate_build_params.go b/aggsender/types/certificate_build_params.go new file mode 100644 index 00000000..f7775415 --- /dev/null +++ b/aggsender/types/certificate_build_params.go @@ -0,0 +1,101 @@ +package types + +import ( + "fmt" + + "github.com/0xPolygon/cdk/bridgesync" +) + +const ( + EstimatedSizeBridgeExit = 250 + EstimatedSizeClaim = 44000 +) + +// CertificateBuildParams is a struct that holds the parameters to build a certificate +type CertificateBuildParams struct { + FromBlock uint64 + ToBlock uint64 + Bridges []bridgesync.Bridge + Claims []bridgesync.Claim +} + +func (c *CertificateBuildParams) String() string { + return fmt.Sprintf("FromBlock: %d, ToBlock: %d, numBridges: %d, numClaims: %d", + c.FromBlock, c.ToBlock, c.NumberOfBridges(), c.NumberOfClaims()) +} + +// Range create a new CertificateBuildParams with the given range +func (c *CertificateBuildParams) Range(fromBlock, toBlock uint64) (*CertificateBuildParams, error) { + if c.FromBlock == fromBlock && c.ToBlock == toBlock { + return c, nil + } + if c.FromBlock > fromBlock || c.ToBlock < toBlock { + return nil, fmt.Errorf("invalid range") + } + newCert := &CertificateBuildParams{ + FromBlock: fromBlock, + ToBlock: toBlock, + Bridges: make([]bridgesync.Bridge, 0), + Claims: make([]bridgesync.Claim, 0), + } + + for _, bridge := range c.Bridges { + if bridge.BlockNum >= fromBlock && bridge.BlockNum <= toBlock { + newCert.Bridges = append(newCert.Bridges, bridge) + } + } + + for _, claim := range c.Claims { + if claim.BlockNum >= fromBlock && claim.BlockNum <= toBlock { + newCert.Claims = append(newCert.Claims, claim) + } + } + return newCert, nil +} + +// NumberOfBridges returns the number of bridges in the certificate +func (c *CertificateBuildParams) NumberOfBridges() int { + if c == nil { + return 0 + } + return len(c.Bridges) +} + +// NumberOfClaims returns the number of claims in the certificate +func (c *CertificateBuildParams) NumberOfClaims() int { + if c == nil { + return 0 + } + return len(c.Claims) +} + +// NumberOfBlocks returns the number of blocks in the certificate +func (c *CertificateBuildParams) NumberOfBlocks() int { + if c == nil { + return 0 + } + return int(c.ToBlock - c.FromBlock + 1) +} + +// EstimatedSize returns the estimated size of the certificate +func (c *CertificateBuildParams) EstimatedSize() uint { + if c == nil { + return 0 + } + numBridges := len(c.Bridges) + numClaims := len(c.Claims) + return uint(numBridges*EstimatedSizeBridgeExit + numClaims*EstimatedSizeClaim) +} + +// IsEmpty returns true if the certificate is empty +func (c *CertificateBuildParams) IsEmpty() bool { + return c.NumberOfBridges() == 0 && c.NumberOfClaims() == 0 +} + +// MaxDepoitCount returns the maximum deposit count in the certificate +func (c *CertificateBuildParams) MaxDepoitCount() uint32 { + if c == nil || c.NumberOfBridges() == 0 { + return 0 + } + return c.Bridges[len(c.Bridges)-1].DepositCount +}