synapsecns/sanguine

package types

import (
    "fmt"
    "github.com/ethereum/go-ethereum/crypto"
)

// MessageFlag indicates if the message is normal "Base" message or "Manager" message.
type MessageFlag uint8

const (
    // MessageFlagBase is the normal message that has tips.
    MessageFlagBase MessageFlag = iota
    // MessageFlagManager is manager message and will not have tips.
    MessageFlagManager
)

const (
    // MessageFlagSize if the size in bytes of a message flag.
    MessageFlagSize = 1
    // MessageHeaderSize is the size in bytes of a message header.
    MessageHeaderSize = 4*4 + MessageFlagSize
)

// Header contains information of a message.
type Header interface {
    // Flag is the flag of the message
    Flag() MessageFlag
    // OriginDomain is the origin domain of the message
    OriginDomain() uint32
    // Nonce is the nonce of the message
    Nonce() uint32
    // DestinationDomain is the destination domain of the message
    DestinationDomain() uint32
    // OptimisticSeconds is the optimistic time period of the message in seconds
    OptimisticSeconds() uint32

    // Leaf is the leaf of the header.
    Leaf() ([32]byte, error)
}

type headerImpl struct {
    flag              MessageFlag
    originDomain      uint32
    nonce             uint32
    destinationDomain uint32
    optimisticSeconds uint32
}

// NewHeader creates a new header type.
func NewHeader(flag MessageFlag, originDomain uint32, nonce uint32, destinationDomain uint32, optimisticSeconds uint32) Header {
    return &headerImpl{
        flag:              flag,
        originDomain:      originDomain,
        nonce:             nonce,
        destinationDomain: destinationDomain,
        optimisticSeconds: optimisticSeconds,
    }
}

func (h headerImpl) Flag() MessageFlag {
    return h.flag
}

func (h headerImpl) OriginDomain() uint32 {
    return h.originDomain
}

func (h headerImpl) Nonce() uint32 {
    return h.nonce
}

func (h headerImpl) DestinationDomain() uint32 {
    return h.destinationDomain
}

func (h headerImpl) OptimisticSeconds() uint32 {
    return h.optimisticSeconds
}

func (h headerImpl) Leaf() ([32]byte, error) {
    var paddedHeader [32]byte
    bytesHeader, err := EncodeHeader(h)
    if err != nil {
        return [32]byte{}, fmt.Errorf("failed to encode header: %w", err)
    }

    // Determine where to start copying bytesHeader into paddedHeader
    startIndex := len(paddedHeader) - len(bytesHeader)
    copy(paddedHeader[startIndex:], bytesHeader)

    // Pad the beginning bytes with zeros
    for i := 0; i < startIndex; i++ {
        paddedHeader[i] = 0
    }

    headerHash := crypto.Keccak256(paddedHeader[:])

    var headerHash32Byte [32]byte
    copy(headerHash32Byte[:], headerHash)

    return headerHash32Byte, nil
}