chore: Converting message and proposal fields to generics

chains/evm/chain.go

@@ -18,11 +18,11 @@ type EventListener interface {
 }
 
 type ProposalExecutor interface {
-	Execute(props []*proposal.Proposal) error
+	Execute(props []*proposal.Proposal[any]) error
 }
 
 type MessageHandler interface {
-	HandleMessage(m *message.Message) (*proposal.Proposal, error)
+	HandleMessage(m *message.Message[any]) (*proposal.Proposal[any], error)
 }
 
 // EVMChain is struct that aggregates all data required for
@@ -55,11 +55,11 @@ func (c *EVMChain) PollEvents(ctx context.Context) {
 	go c.listener.ListenToEvents(ctx, c.startBlock)
 }
 
-func (c *EVMChain) ReceiveMessage(m *message.Message) (*proposal.Proposal, error) {
+func (c *EVMChain) ReceiveMessage(m *message.Message[any]) (*proposal.Proposal[any], error) {
 	return c.messageHandler.HandleMessage(m)
 }
 
-func (c *EVMChain) Write(props []*proposal.Proposal) error {
+func (c *EVMChain) Write(props []*proposal.Proposal[any]) error {
 	err := c.executor.Execute(props)
 	if err != nil {
 		c.logger.Err(err).Msgf("error writing proposals %+v on network %d", props, c.DomainID())

chains/substrate/chain.go

@@ -11,11 +11,11 @@ import (
 )
 
 type ProposalExecutor interface {
-	Execute(props []*proposal.Proposal) error
+	Execute(props []*proposal.Proposal[any]) error
 }
 
 type MessageHandler interface {
-	HandleMessage(m *message.Message) (*proposal.Proposal, error)
+	HandleMessage(m *message.Message[any]) (*proposal.Proposal[any], error)
 }
 
 type EventListener interface {
@@ -49,11 +49,11 @@ func (c *SubstrateChain) PollEvents(ctx context.Context) {
 	go c.listener.ListenToEvents(ctx, c.startBlock)
 }
 
-func (c *SubstrateChain) ReceiveMessage(m *message.Message) (*proposal.Proposal, error) {
+func (c *SubstrateChain) ReceiveMessage(m *message.Message[any]) (*proposal.Proposal[any], error) {
 	return c.messageHandler.HandleMessage(m)
 }
 
-func (c *SubstrateChain) Write(props []*proposal.Proposal) error {
+func (c *SubstrateChain) Write(props []*proposal.Proposal[any]) error {
 	err := c.executor.Execute(props)
 	if err != nil {
 		c.logger.Err(err).Msgf("error writing proposals %+v on network %d", props, c.DomainID())

relayer/message/handler.go

@@ -7,7 +7,7 @@ import (
 )
 
 type Handler interface {
-	HandleMessage(m *Message) (*proposal.Proposal, error)
+	HandleMessage(m *Message[any]) (*proposal.Proposal[any], error)
 }
 
 type MessageHandler struct {
@@ -21,7 +21,7 @@ func NewMessageHandler() *MessageHandler {
 }
 
 // HandlerMessage calls associated handler for that message type and returns a proposal to be submitted on-chain
-func (h *MessageHandler) HandleMessage(m *Message) (*proposal.Proposal, error) {
+func (h *MessageHandler) HandleMessage(m *Message[any]) (*proposal.Proposal[any], error) {
 	mh, ok := h.handlers[m.Type]
 	if !ok {
 		return nil, fmt.Errorf("no handler found for type %s", m.Type)

relayer/message/handler_test.go

@@ -29,7 +29,7 @@ func (s *MessageHandlerTestSuite) SetupTest() {
 func (s *MessageHandlerTestSuite) TestHandleMessageWithoutRegisteredHandler() {
 	mh := message.NewMessageHandler()
 
-	_, err := mh.HandleMessage(&message.Message{Type: "invalid"})
+	_, err := mh.HandleMessage(&message.Message[any]{Type: "invalid"})
 
 	s.NotNil(err)
 }
@@ -38,7 +38,7 @@ func (s *MessageHandlerTestSuite) TestHandleMessageWithInvalidType() {
 	mh := message.NewMessageHandler()
 	mh.RegisterMessageHandler("invalid", s.mockHandler)
 
-	_, err := mh.HandleMessage(&message.Message{Type: "valid"})
+	_, err := mh.HandleMessage(&message.Message[any]{Type: "valid"})
 
 	s.NotNil(err)
 }
@@ -49,21 +49,21 @@ func (s *MessageHandlerTestSuite) TestHandleMessageHandlerReturnsError() {
 	mh := message.NewMessageHandler()
 	mh.RegisterMessageHandler("valid", s.mockHandler)
 
-	_, err := mh.HandleMessage(&message.Message{Type: "valid"})
+	_, err := mh.HandleMessage(&message.Message[any]{Type: "valid"})
 
 	s.NotNil(err)
 }
 
 func (s *MessageHandlerTestSuite) TestHandleMessageWithValidType() {
-	expectedProp := &proposal.Proposal{
+	expectedProp := &proposal.Proposal[any]{
 		Type: "prop",
 	}
 	s.mockHandler.EXPECT().HandleMessage(gomock.Any()).Return(expectedProp, nil)
 
 	mh := message.NewMessageHandler()
 	mh.RegisterMessageHandler("valid", s.mockHandler)
 
-	msg := message.NewMessage(1, 2, nil, "valid")
+	msg := message.NewMessage[any](1, 2, nil, "valid")
 	prop, err := mh.HandleMessage(msg)
 
 	s.Nil(err)

relayer/message/message.go

@@ -1,20 +1,20 @@
 package message
 
 type MessageType string
-type Message struct {
+type Message[T any] struct {
 	Source      uint8       // Source where message was initiated
 	Destination uint8       // Destination chain of message
-	Data        interface{} // Data associated with the message
+	Data        T           // Data associated with the message
 	Type        MessageType // Message type
 }
 
-func NewMessage(
+func NewMessage[T any](
 	source uint8,
 	destination uint8,
-	data interface{},
+	data T,
 	msgType MessageType,
-) *Message {
-	return &Message{
+) *Message[T] {
+	return &Message[T]{
 		source,
 		destination,
 		data,

relayer/proposal/proposal.go

@@ -1,15 +1,15 @@
 package proposal
 
 type ProposalType string
-type Proposal struct {
+type Proposal[T any] struct {
 	Source      uint8
 	Destination uint8
-	Data        interface{}
+	Data        T
 	Type        ProposalType
 }
 
-func NewProposal(source, destination uint8, data []byte, propType ProposalType) *Proposal {
-	return &Proposal{
+func NewProposal[T any](source, destination uint8, data T, propType ProposalType) *Proposal[T] {
+	return &Proposal[T]{
 		Source:      source,
 		Destination: destination,
 		Data:        data,

relayer/relayer.go

@@ -16,10 +16,10 @@ type RelayedChain interface {
 	PollEvents(ctx context.Context)
 	// ReceiveMessage accepts the message from the source chain and converts it into
 	// a Proposal to be submitted on-chain
-	ReceiveMessage(m *message.Message) (*proposal.Proposal, error)
+	ReceiveMessage(m *message.Message[any]) (*proposal.Proposal[any], error)
 	// Write submits proposals on-chain.
 	// If multiple proposals submitted they are expected to be able to be batched.
-	Write(proposals []*proposal.Proposal) error
+	Write(proposals []*proposal.Proposal[any]) error
 	DomainID() uint8
 }
 
@@ -34,7 +34,7 @@ type Relayer struct {
 // Start function starts polling events for each chain and listens to cross-chain messages.
 // If an array of messages is sent to the channel they are expected to be to the same destination and
 // able to be handled in batches.
-func (r *Relayer) Start(ctx context.Context, msgChan chan []*message.Message) {
+func (r *Relayer) Start(ctx context.Context, msgChan chan []*message.Message[any]) {
 	log.Info().Msgf("Starting relayer")
 
 	for _, c := range r.relayedChains {
@@ -54,14 +54,14 @@ func (r *Relayer) Start(ctx context.Context, msgChan chan []*message.Message) {
 }
 
 // Route function routes the messages to the destination chain.
-func (r *Relayer) route(msgs []*message.Message) {
+func (r *Relayer) route(msgs []*message.Message[any]) {
 	destChain, ok := r.relayedChains[msgs[0].Destination]
 	if !ok {
 		log.Error().Uint8("domainID", destChain.DomainID()).Msgf("No chain registered for destination domain")
 		return
 	}
 
-	props := make([]*proposal.Proposal, 0)
+	props := make([]*proposal.Proposal[any], 0)
 	for _, m := range msgs {
 		prop, err := destChain.ReceiveMessage(m)
 		if err != nil {

relayer/relayer_test.go

@@ -46,8 +46,8 @@ func (s *RouteTestSuite) TestStartListensOnChannel() {
 		chains,
 	)
 
-	msgChan := make(chan []*message.Message, 1)
-	msgChan <- []*message.Message{
+	msgChan := make(chan []*message.Message[any], 1)
+	msgChan <- []*message.Message[any]{
 		{Destination: 1},
 	}
 	relayer.Start(ctx, msgChan)
@@ -63,7 +63,7 @@ func (s *RouteTestSuite) TestReceiveMessageFails() {
 		chains,
 	)
 
-	relayer.route([]*message.Message{
+	relayer.route([]*message.Message[any]{
 		{Destination: 1},
 	})
 }
@@ -76,14 +76,14 @@ func (s *RouteTestSuite) TestAvoidWriteWithoutProposals() {
 		chains,
 	)
 
-	relayer.route([]*message.Message{
+	relayer.route([]*message.Message[any]{
 		{Destination: 1},
 	})
 }
 
 func (s *RouteTestSuite) TestWriteFails() {
-	props := make([]*proposal.Proposal, 1)
-	prop := &proposal.Proposal{}
+	props := make([]*proposal.Proposal[any], 1)
+	prop := &proposal.Proposal[any]{}
 	props[0] = prop
 	s.mockRelayedChain.EXPECT().ReceiveMessage(gomock.Any()).Return(prop, nil)
 	s.mockRelayedChain.EXPECT().Write(props).Return(fmt.Errorf("error"))
@@ -94,14 +94,14 @@ func (s *RouteTestSuite) TestWriteFails() {
 		chains,
 	)
 
-	relayer.route([]*message.Message{
+	relayer.route([]*message.Message[any]{
 		{Destination: 1},
 	})
 }
 
 func (s *RouteTestSuite) TestWritesToChain() {
-	props := make([]*proposal.Proposal, 1)
-	prop := &proposal.Proposal{}
+	props := make([]*proposal.Proposal[any], 1)
+	prop := &proposal.Proposal[any]{}
 	props[0] = prop
 	s.mockRelayedChain.EXPECT().ReceiveMessage(gomock.Any()).Return(prop, nil)
 	s.mockRelayedChain.EXPECT().Write(props).Return(nil)
@@ -111,7 +111,7 @@ func (s *RouteTestSuite) TestWritesToChain() {
 		chains,
 	)
 
-	relayer.route([]*message.Message{
+	relayer.route([]*message.Message[any]{
 		{Destination: 1},
 	})
 }