diff --git a/aggsender/aggsender.go b/aggsender/aggsender.go index feed4a39..ec2bdd8a 100644 --- a/aggsender/aggsender.go +++ b/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", } diff --git a/aggsender/aggsender_test.go b/aggsender/aggsender_test.go index 331d3c7e..1fdcddb2 100644 --- a/aggsender/aggsender_test.go +++ b/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(), } } diff --git a/aggsender/types/types.go b/aggsender/types/types.go index f52b29f3..40f80439 100644 --- a/aggsender/types/types.go +++ b/aggsender/types/types.go @@ -129,16 +129,18 @@ 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, } } @@ -146,30 +148,40 @@ func NewCertificateMetadata(fromBlock, toBlock, createdAt uint64) *CertificateMe 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 diff --git a/aggsender/types/types_test.go b/aggsender/types/types_test.go index 537cc182..85f6f763 100644 --- a/aggsender/types/types_test.go +++ b/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) }