synapsecns/sanguine

package types_test

import (
    "testing"

    "github.com/brianvoe/gofakeit/v6"
    . "github.com/stretchr/testify/assert"
    "github.com/synapsecns/sanguine/agents/types"
)

func TestRequestEncodeDecode(t *testing.T) {
    version := uint32(1)
    gasLimit := gofakeit.Uint64()
    gasDrop := randomUint64BigInt(t)

    ogRequest, err := types.EncodeRequest(types.NewRequest(version, gasLimit, gasDrop))
    Nil(t, err)

    decodedRequest := types.DecodeRequest(ogRequest)

    Equal(t, decodedRequest.Version(), version)
    Equal(t, decodedRequest.GasLimit(), gasLimit)
    Equal(t, decodedRequest.GasDrop(), gasDrop)
}

func TestEncodeDecodeTips(t *testing.T) {
    // we want to make sure we can deal w/ overflows
    summitTip := randomUint64BigInt(t)
    attestationTip := randomUint64BigInt(t)
    executionTip := randomUint64BigInt(t)
    deliveryTip := randomUint64BigInt(t)

    encodedTips, err := types.EncodeTips(types.NewTips(summitTip, attestationTip, executionTip, deliveryTip))
    Nil(t, err)

    decodedTips, err := types.DecodeTips(encodedTips)
    Nil(t, err)

    Equal(t, decodedTips.SummitTip(), summitTip)
    Equal(t, decodedTips.AttestationTip(), attestationTip)
    Equal(t, decodedTips.ExecutionTip(), executionTip)
    Equal(t, decodedTips.DeliveryTip(), deliveryTip)
}

func TestEncodeDecodeBaseMessage(t *testing.T) {
    senderBytes := randomUint64BigInt(t).Bytes()
    var sender [32]byte
    copy(sender[:], senderBytes)

    recipientBytes := randomUint64BigInt(t).Bytes()
    var recipient [32]byte
    copy(recipient[:], recipientBytes)

    summitTip := randomUint64BigInt(t)
    attestationTip := randomUint64BigInt(t)
    executionTip := randomUint64BigInt(t)
    deliveryTip := randomUint64BigInt(t)

    tips := types.NewTips(summitTip, attestationTip, executionTip, deliveryTip)

    version := uint32(1)
    gasLimit := gofakeit.Uint64()
    gasDrop := randomUint64BigInt(t)

    request := types.NewRequest(version, gasLimit, gasDrop)

    content := randomUint64BigInt(t).Bytes()

    encodedBaseMessage, err := types.EncodeBaseMessage(types.NewBaseMessage(sender, recipient, tips, request, content))
    Nil(t, err)

    decodedBaseMessage, err := types.DecodeBaseMessage(encodedBaseMessage)
    Nil(t, err)

    Equal(t, decodedBaseMessage.Sender(), sender)
    Equal(t, decodedBaseMessage.Recipient(), recipient)
    Equal(t, decodedBaseMessage.Tips().SummitTip().Uint64(), tips.SummitTip().Uint64())
    Equal(t, decodedBaseMessage.Tips().AttestationTip().Uint64(), tips.AttestationTip().Uint64())
    Equal(t, decodedBaseMessage.Tips().DeliveryTip().Uint64(), tips.DeliveryTip().Uint64())
    Equal(t, decodedBaseMessage.Tips().ExecutionTip().Uint64(), tips.ExecutionTip().Uint64())
    Equal(t, decodedBaseMessage.Request().Version(), request.Version())
    Equal(t, decodedBaseMessage.Request().GasLimit(), request.GasLimit())
    Equal(t, decodedBaseMessage.Request().GasDrop().Uint64(), request.GasDrop().Uint64())
    Equal(t, decodedBaseMessage.Content(), content)
}

func TestNewMessageEncodeDecode(t *testing.T) {
    origin := gofakeit.Uint32()
    nonce := gofakeit.Uint32()
    destination := gofakeit.Uint32()
    body := []byte(gofakeit.Sentence(gofakeit.Number(5, 15)))
    optimisticSeconds := gofakeit.Uint32()

    flag := types.MessageFlagManager

    header := types.NewHeader(
        flag, origin, nonce, destination, optimisticSeconds)

    newMessage := types.NewMessage(header, nil, body)

    Equal(t, newMessage.Header().Flag(), flag)
    Equal(t, newMessage.OriginDomain(), origin)
    Equal(t, newMessage.Nonce(), nonce)
    Equal(t, newMessage.DestinationDomain(), destination)
    Equal(t, newMessage.Body(), body)

    encodedMessage, err := types.EncodeMessage(newMessage)
    Nil(t, err)

    // make sure decode is same as encode
    decodedMessage, err := types.DecodeMessage(encodedMessage)
    Nil(t, err)

    Equal(t, newMessage.OriginDomain(), decodedMessage.OriginDomain())
    Equal(t, newMessage.Nonce(), decodedMessage.Nonce())
    Equal(t, newMessage.DestinationDomain(), decodedMessage.DestinationDomain())
    Equal(t, newMessage.Body(), decodedMessage.Body())
}

func TestHeaderEncodeDecode(t *testing.T) {
    origin := gofakeit.Uint32()
    nonce := gofakeit.Uint32()
    destination := gofakeit.Uint32()
    optimisticSeconds := gofakeit.Uint32()

    flag := types.MessageFlagManager
    ogHeader, err := types.EncodeHeader(types.NewHeader(flag, origin, nonce, destination, optimisticSeconds))
    Nil(t, err)

    decodedHeader, err := types.DecodeHeader(ogHeader)
    Nil(t, err)

    Equal(t, decodedHeader.Flag(), flag)
    Equal(t, decodedHeader.OriginDomain(), origin)
    Equal(t, decodedHeader.Nonce(), nonce)
    Equal(t, decodedHeader.DestinationDomain(), destination)
    Equal(t, decodedHeader.OptimisticSeconds(), optimisticSeconds)
}

func TestChainGasEncodeDecode(t *testing.T) {
    domain := gofakeit.Uint32()

    gasPrice := gofakeit.Uint16()
    dataPrice := gofakeit.Uint16()
    execBuffer := gofakeit.Uint16()
    amortAttCost := gofakeit.Uint16()
    etherPrice := gofakeit.Uint16()
    markup := gofakeit.Uint16()

    gasData := types.NewGasData(gasPrice, dataPrice, execBuffer, amortAttCost, etherPrice, markup)

    chainGas := types.NewChainGas(gasData, domain)

    encodedChainGas, err := types.EncodeChainGas(chainGas)
    Nil(t, err)

    decodedChainGas, err := types.DecodeChainGas(encodedChainGas)
    Nil(t, err)

    Equal(t, chainGas.Domain(), decodedChainGas.Domain())
    Equal(t, chainGas.GasData().GasPrice(), decodedChainGas.GasData().GasPrice())
    Equal(t, chainGas.GasData().DataPrice(), decodedChainGas.GasData().DataPrice())
    Equal(t, chainGas.GasData().DataPrice(), decodedChainGas.GasData().DataPrice())
    Equal(t, chainGas.GasData().ExecBuffer(), decodedChainGas.GasData().ExecBuffer())
    Equal(t, chainGas.GasData().AmortAttCost(), decodedChainGas.GasData().AmortAttCost())
    Equal(t, chainGas.GasData().EtherPrice(), decodedChainGas.GasData().EtherPrice())
    Equal(t, chainGas.GasData().Markup(), decodedChainGas.GasData().Markup())
}