fix merge issues

aggsender/aggsender.go

@@ -6,7 +6,6 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"math/big"
 	"os"
 	"time"
 
@@ -396,8 +395,8 @@ func (a *AggSender) buildCertificate(ctx context.Context,
 
 	meta := types.NewCertificateMetadata(
 		certParams.FromBlock,
-		certParams.ToBlock,
-		uint64(time.Now().UTC().UnixMilli()),
+		uint32(certParams.ToBlock-certParams.FromBlock),
+		uint32(time.Now().UTC().Unix()),
 	)
 
 	return &agglayer.Certificate{
@@ -775,28 +774,21 @@ func extractSignatureData(signature []byte) (r, s common.Hash, isOddParity bool,
 	return
 }
 
-// createCertificateMetadata creates a certificate metadata from given input
-func createCertificateMetadata(toBlock uint64) common.Hash {
-	return common.BigToHash(new(big.Int).SetUint64(toBlock))
-}
-
-func extractFromCertificateMetadataToBlock(metadata common.Hash) uint64 {
-	return metadata.Big().Uint64()
-}
-
 func NewCertificateInfoFromAgglayerCertHeader(c *agglayer.CertificateHeader) *types.CertificateInfo {
 	if c == nil {
 		return nil
 	}
 	now := time.Now().UTC().UnixMilli()
+	meta := types.NewCertificateMetadataFromHash(c.Metadata)
+
 	res := &types.CertificateInfo{
 		Height:            c.Height,
 		CertificateID:     c.CertificateID,
 		NewLocalExitRoot:  c.NewLocalExitRoot,
-		FromBlock:         0,
-		ToBlock:           extractFromCertificateMetadataToBlock(c.Metadata),
+		FromBlock:         meta.FromBlock,
+		ToBlock:           meta.FromBlock + uint64(meta.Offset),
 		Status:            c.Status,
-		CreatedAt:         now,
+		CreatedAt:         int64(meta.CreatedAt),
 		UpdatedAt:         now,
 		SignedCertificate: "na/agglayer header",
 	}

aggsender/aggsender_test.go

@@ -1709,22 +1709,25 @@ func TestExtractFromCertificateMetadataToBlock(t *testing.T) {
 	tests := []struct {
 		name     string
 		metadata common.Hash
-		expected uint64
+		expected aggsendertypes.CertificateMetadata
 	}{
 		{
 			name:     "Valid metadata",
-			metadata: common.BigToHash(big.NewInt(123567890)),
-			expected: 123567890,
+			metadata: aggsendertypes.NewCertificateMetadata(0, 123567890, 123567890).ToHash(),
+			expected: aggsendertypes.CertificateMetadata{
+				FromBlock: 0,
+				Offset:    1000,
+				CreatedAt: 123567890,
+			},
 		},
 		{
 			name:     "Zero metadata",
-			metadata: common.BigToHash(big.NewInt(0)),
-			expected: 0,
-		},
-		{
-			name:     "Max uint64 metadata",
-			metadata: common.BigToHash(new(big.Int).SetUint64(^uint64(0))),
-			expected: ^uint64(0),
+			metadata: aggsendertypes.NewCertificateMetadata(0, 0, 0).ToHash(),
+			expected: aggsendertypes.CertificateMetadata{
+				FromBlock: 0,
+				Offset:    0,
+				CreatedAt: 0,
+			},
 		},
 	}
 
@@ -1734,7 +1737,7 @@ func TestExtractFromCertificateMetadataToBlock(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			result := extractFromCertificateMetadataToBlock(tt.metadata)
+			result := *aggsendertypes.NewCertificateMetadataFromHash(tt.metadata)
 			require.Equal(t, tt.expected, result)
 		})
 	}
@@ -2014,7 +2017,11 @@ func certInfoToCertHeader(t *testing.T, certInfo *aggsendertypes.CertificateInfo
 		CertificateID:    certInfo.CertificateID,
 		NewLocalExitRoot: certInfo.NewLocalExitRoot,
 		Status:           agglayer.Pending,
-		Metadata:         createCertificateMetadata(certInfo.ToBlock),
+		Metadata: aggsendertypes.NewCertificateMetadata(
+			certInfo.FromBlock,
+			uint32(certInfo.FromBlock-certInfo.ToBlock),
+			uint32(certInfo.CreatedAt),
+		).ToHash(),
 	}
 }
 

aggsender/types/types.go

@@ -129,47 +129,59 @@ func (c *CertificateInfo) ElapsedTimeSinceCreation() time.Duration {
 
 type CertificateMetadata struct {
 	FromBlock uint64 `json:"fromBlock"`
-	ToBlock   uint64 `json:"toBlock"`
-	CreatedAt uint64 `json:"createdAt"`
+	Offset    uint32 `json:"toBlock"`
+	CreatedAt uint32 `json:"createdAt"`
+	Version   uint8  `json:"version"`
 }
 
 // NewCertificateMetadataFromHash returns a new CertificateMetadata from the given hash
-func NewCertificateMetadata(fromBlock, toBlock, createdAt uint64) *CertificateMetadata {
+func NewCertificateMetadata(fromBlock uint64, offset uint32, createdAt uint32) *CertificateMetadata {
 	return &CertificateMetadata{
 		FromBlock: fromBlock,
-		ToBlock:   toBlock,
+		Offset:    offset,
 		CreatedAt: createdAt,
+		Version:   1,
 	}
 }
 
 // NewCertificateMetadataFromHash returns a new CertificateMetadata from the given hash
 func NewCertificateMetadataFromHash(hash common.Hash) *CertificateMetadata {
 	b := hash.Bytes()
 
-	return NewCertificateMetadata(
-		binary.BigEndian.Uint64(b[16:24]),
-		binary.BigEndian.Uint64(b[24:32]),
-		binary.BigEndian.Uint64(b[8:16]),
-	)
+	if b[0] < 1 {
+		hash.Big().Uint64()
+
+		return &CertificateMetadata{
+			Version:   b[0],
+			FromBlock: binary.BigEndian.Uint64(b[1:9]),
+			Offset:    binary.BigEndian.Uint32(b[9:13]),
+			CreatedAt: binary.BigEndian.Uint32(b[13:17]),
+		}
+	}
+
+	return &CertificateMetadata{
+		Version:   b[0],
+		FromBlock: binary.BigEndian.Uint64(b[1:9]),
+		Offset:    binary.BigEndian.Uint32(b[9:13]),
+		CreatedAt: binary.BigEndian.Uint32(b[13:17]),
+	}
 }
 
 // ToHash returns the hash of the metadata
 func (c *CertificateMetadata) ToHash() common.Hash {
 	b := make([]byte, common.HashLength) // 32-byte hash
 
-	// We encode the metadata with padding 0's at the start,
-	// because previous versions of the code stored the toBlock
-	// at the end of the hash, and we need to be able to decode
-	// those hashes.
-
-	// Encode createdAt
-	binary.BigEndian.PutUint64(b[8:16], c.CreatedAt)
+	// Encode version
+	b[0] = c.Version
 
 	// Encode fromBlock
-	binary.BigEndian.PutUint64(b[16:24], c.FromBlock)
+	binary.BigEndian.PutUint64(b[1:9], c.FromBlock)
 
-	// Encode toBlock
-	binary.BigEndian.PutUint64(b[24:32], c.ToBlock)
+	// Encode offset
+	binary.BigEndian.PutUint32(b[9:13], c.Offset)
+
+	// Encode createdAt
+	binary.BigEndian.PutUint32(b[13:17], c.CreatedAt)
 
 	// Last 8 bytes remain as zero padding
 

aggsender/types/types_test.go

@@ -12,17 +12,17 @@ func TestMetadataConversions_toBlock_Only(t *testing.T) {
 	toBlock := uint64(123567890)
 	hash := common.BigToHash(new(big.Int).SetUint64(toBlock))
 	extractBlock := NewCertificateMetadataFromHash(hash)
-	require.Equal(t, toBlock, extractBlock.ToBlock)
+	require.Equal(t, toBlock, extractBlock.FromBlock)
 }
 
 func TestMetadataConversions(t *testing.T) {
 	fromBlock := uint64(123567890)
-	toBlock := uint64(123567890)
-	createdAt := uint64(0)
-	meta := NewCertificateMetadata(fromBlock, toBlock, createdAt)
+	offset := uint32(1000)
+	createdAt := uint32(0)
+	meta := NewCertificateMetadata(fromBlock, offset, createdAt)
 	c := meta.ToHash()
 	extractBlock := NewCertificateMetadataFromHash(c)
 	require.Equal(t, fromBlock, extractBlock.FromBlock)
-	require.Equal(t, toBlock, extractBlock.ToBlock)
+	require.Equal(t, offset, extractBlock.Offset)
 	require.Equal(t, createdAt, extractBlock.CreatedAt)
 }