API endpoint for manually relaying warp message

README.md

@@ -319,12 +319,12 @@ The relayer consists of the following components:
 ### API
 
 #### `/relay`
-- Used to manually relay a warp message. The body of the request must contain the following JSON:
+- Used to manually relay a Warp message. The body of the request must contain the following JSON:
 ```json
 {
  "blockchain-id": "<cb58-encoding of blockchain ID>",
- "message-id": "<Hex encoding of warp message ID>",
- "block-num": <Integer representation of the block number that the message was sent in>
+ "message-id": "<Hex encoding of Warp message ID>",
+ "block-num": "<Integer representation of the block number that the message was sent in>"
 }
 ```
 - If successful, the endpoint will return the following JSON:
@@ -338,14 +338,14 @@ The relayer consists of the following components:
 - Used to manually relay a warp message. The body of the request must contain the following JSON:
 ```json
 {
- "unsigned-message-bytes": "<byte array containing the unsigned warp message>",
+ "unsigned-message-bytes": "<Hex encoded byte array containing the unsigned warp message>",
  "source-address": "<Hex encoding of address that sent the warp message>"
 }
 ```
 - If successful, the endpoint will return the following JSON:
 ```json
 {
- "transaction-hash": "<Transaction hash that includes the delivered warp message>",
+ "transaction-hash": "<Transaction hash that includes the delivered Warp message>",
 }
 ```
 
@@ -358,7 +358,7 @@ The relayer consists of the following components:
     "relayers-all": {
       "status": "down",
       "timestamp": "2024-06-01T05:06:07.685522Z",
-      "error": "<List of cb-58 encoded IDs for unhealth relayers>"
+      "error": "<List of cb-58 encoded IDs for unhealthy relayers>"
     }
   }
 }

api/relay_message.go

@@ -5,12 +5,13 @@ import (
 	"math/big"
 	"net/http"
 
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/avalanchego/utils/logging"
 	"github.com/ava-labs/awm-relayer/relayer"
 	"github.com/ava-labs/awm-relayer/types"
 	relayerTypes "github.com/ava-labs/awm-relayer/types"
-
-	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ethereum/go-ethereum/common"
+	"go.uber.org/zap"
 )
 
 const (
@@ -21,7 +22,7 @@ const (
 type RelayMessageRequest struct {
 	// Required. cb58 encoding of the source blockchain ID for the message
 	BlockchainID string `json:"blockchain-id"`
-	// Required. Hex encoding of the warp message ID
+	// Required. cb58 encoding of the warp message ID
 	MessageID string `json:"message-id"`
 	// Required. Integer representation of the block number that the message was sent in
 	BlockNum string `json:"block-num"`
@@ -38,25 +39,27 @@ type ManualWarpMessageRequest struct {
 	SourceAddress        string `json:"source-address"`
 }
 
-func HandleRelayMessage(messageCoordinator *relayer.MessageCoordinator) {
-	http.Handle(RelayAPIPath, relayAPIHandler(messageCoordinator))
+func HandleRelayMessage(logger logging.Logger, messageCoordinator *relayer.MessageCoordinator) {
+	http.Handle(RelayAPIPath, relayAPIHandler(logger, messageCoordinator))
 }
 
-func HandleRelay(messageCoordinator *relayer.MessageCoordinator) {
-	http.Handle(RelayMessageAPIPath, relayMessageAPIHandler(messageCoordinator))
+func HandleRelay(logger logging.Logger, messageCoordinator *relayer.MessageCoordinator) {
+	http.Handle(RelayMessageAPIPath, relayMessageAPIHandler(logger, messageCoordinator))
 }
 
-func relayMessageAPIHandler(messageCoordinator *relayer.MessageCoordinator) http.Handler {
+func relayMessageAPIHandler(logger logging.Logger, messageCoordinator *relayer.MessageCoordinator) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		var req ManualWarpMessageRequest
 		err := json.NewDecoder(r.Body).Decode(&req)
 		if err != nil {
+			logger.Warn("could not decode request body")
 			http.Error(w, err.Error(), http.StatusBadRequest)
 			return
 		}
 
 		unsignedMessage, err := types.UnpackWarpMessage(req.UnsignedMessageBytes)
 		if err != nil {
+			logger.Warn("error unpacking warp message", zap.Error(err))
 			http.Error(w, err.Error(), http.StatusBadRequest)
 			return
 		}
@@ -68,6 +71,7 @@ func relayMessageAPIHandler(messageCoordinator *relayer.MessageCoordinator) http
 
 		txHash, err := messageCoordinator.ProcessWarpMessage(warpMessageInfo)
 		if err != nil {
+			logger.Error("error processing message", zap.Error(err))
 			http.Error(w, "error processing message: "+err.Error(), http.StatusInternalServerError)
 			return
 		}
@@ -78,37 +82,50 @@ func relayMessageAPIHandler(messageCoordinator *relayer.MessageCoordinator) http
 			},
 		)
 		if err != nil {
-			http.Error(w, "error writing response: "+err.Error(), http.StatusInternalServerError)
+			logger.Error("error marshaling response", zap.Error(err))
+			http.Error(w, "error marshaling response: "+err.Error(), http.StatusInternalServerError)
 			return
 		}
 
-		_, _ = w.Write(resp)
+		_, err = w.Write(resp)
+		if err != nil {
+			logger.Error("error writing response", zap.Error(err))
+		}
 	})
 }
 
-func relayAPIHandler(messageCoordinator *relayer.MessageCoordinator) http.Handler {
+func relayAPIHandler(logger logging.Logger, messageCoordinator *relayer.MessageCoordinator) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		var req RelayMessageRequest
 		err := json.NewDecoder(r.Body).Decode(&req)
 		if err != nil {
+			logger.Warn("could not decode request body")
 			http.Error(w, err.Error(), http.StatusBadRequest)
 			return
 		}
 
 		blockchainID, err := ids.FromString(req.BlockchainID)
 		if err != nil {
+			logger.Warn("invalid blockchainID", zap.String("blockchainID", req.BlockchainID))
 			http.Error(w, "invalid blockchainID: "+err.Error(), http.StatusBadRequest)
 			return
 		}
-		messageID := common.HexToHash(req.MessageID)
+		messageID, err := ids.FromString(req.MessageID)
+		if err != nil {
+			logger.Warn("invalid messageID", zap.String("messageID", req.MessageID))
+			http.Error(w, "invalid messageID: "+err.Error(), http.StatusBadRequest)
+			return
+		}
 		blockNum, ok := new(big.Int).SetString(req.BlockNum, 10)
 		if !ok {
+			logger.Warn("invalid blockNum", zap.String("blockNum", req.BlockNum))
 			http.Error(w, "invalid blockNum", http.StatusBadRequest)
 			return
 		}
 
 		txHash, err := messageCoordinator.ProcessMessageID(blockchainID, messageID, blockNum)
 		if err != nil {
+			logger.Error("error processing message", zap.Error(err))
 			http.Error(w, "error processing message: "+err.Error(), http.StatusInternalServerError)
 			return
 		}
@@ -119,10 +136,14 @@ func relayAPIHandler(messageCoordinator *relayer.MessageCoordinator) http.Handle
 			},
 		)
 		if err != nil {
-			http.Error(w, "error writing response: "+err.Error(), http.StatusInternalServerError)
+			logger.Error("error marshalling response", zap.Error(err))
+			http.Error(w, "error marshalling response: "+err.Error(), http.StatusInternalServerError)
 			return
 		}
 
-		_, _ = w.Write(resp)
+		_, err = w.Write(resp)
+		if err != nil {
+			logger.Error("error writing response", zap.Error(err))
+		}
 	})
 }

config/config.go

@@ -70,7 +70,7 @@ func DisplayUsageText() {
 
 // Validates the configuration
 // Does not modify the public fields as derived from the configuration passed to the application,
-// but does initialize private fields available through getters
+// but does initialize private fields available through getters.
 func (c *Config) Validate() error {
 	if len(c.SourceBlockchains) == 0 {
 		return errors.New("relayer not configured to relay from any subnets. A list of source subnets must be provided in the configuration file")

main/main.go

@@ -11,10 +11,6 @@ import (
 	"os"
 	"strings"
 
-	"github.com/ava-labs/awm-relayer/messages"
-	offchainregistry "github.com/ava-labs/awm-relayer/messages/off-chain-registry"
-	"github.com/ava-labs/awm-relayer/messages/teleporter"
-
 	"github.com/ava-labs/avalanchego/api/metrics"
 	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/avalanchego/message"
@@ -23,6 +19,9 @@ import (
 	"github.com/ava-labs/awm-relayer/api"
 	"github.com/ava-labs/awm-relayer/config"
 	"github.com/ava-labs/awm-relayer/database"
+	"github.com/ava-labs/awm-relayer/messages"
+	offchainregistry "github.com/ava-labs/awm-relayer/messages/off-chain-registry"
+	"github.com/ava-labs/awm-relayer/messages/teleporter"
 	"github.com/ava-labs/awm-relayer/peers"
 	"github.com/ava-labs/awm-relayer/relayer"
 	"github.com/ava-labs/awm-relayer/utils"
@@ -202,8 +201,8 @@ func main() {
 
 	// Each Listener goroutine will have an atomic bool that it can set to false to indicate an unrecoverable error
 	api.HandleHealthCheck(relayerHealth)
-	api.HandleRelay(messageCoordinator)
-	api.HandleRelayMessage(messageCoordinator)
+	api.HandleRelay(logger, messageCoordinator)
+	api.HandleRelayMessage(logger, messageCoordinator)
 
 	// start the health check server
 	go func() {

relayer/message_coordinator.go

@@ -186,14 +186,14 @@ func (mc *MessageCoordinator) ProcessWarpMessage(warpMessage *relayerTypes.WarpM
 	return appRelayer.ProcessMessage(handler)
 }
 
-func (mc *MessageCoordinator) ProcessMessageID(blockchainID ids.ID, messageID common.Hash, blockNum *big.Int) (common.Hash, error) {
+func (mc *MessageCoordinator) ProcessMessageID(blockchainID ids.ID, messageID ids.ID, blockNum *big.Int) (common.Hash, error) {
 	ethClient, ok := mc.sourceClients[blockchainID]
 	if !ok {
 		mc.logger.Error("Source client not found", zap.String("blockchainID", blockchainID.String()))
 		return common.Hash{}, fmt.Errorf("source client not set for blockchain: %s", blockchainID.String())
 	}
 
-	warpMessage, err := FetchWarpMessageFromID(ethClient, messageID, blockNum)
+	warpMessage, err := FetchWarpMessage(ethClient, messageID, blockNum)
 	if err != nil {
 		mc.logger.Error("Failed to fetch warp from blockchain", zap.String("blockchainID", blockchainID.String()), zap.Error(err))
 		return common.Hash{}, fmt.Errorf("could not fetch warp message from ID: %w", err)
@@ -241,9 +241,9 @@ func (mc *MessageCoordinator) ProcessBlock(blockHeader *types.Header, ethClient
 	}
 }
 
-func FetchWarpMessageFromID(ethClient ethclient.Client, warpID common.Hash, blockNum *big.Int) (*relayerTypes.WarpMessageInfo, error) {
+func FetchWarpMessage(ethClient ethclient.Client, warpID ids.ID, blockNum *big.Int) (*relayerTypes.WarpMessageInfo, error) {
 	logs, err := ethClient.FilterLogs(context.Background(), interfaces.FilterQuery{
-		Topics:    [][]common.Hash{{relayerTypes.WarpPrecompileLogFilter}, nil, {warpID}},
+		Topics:    [][]common.Hash{{relayerTypes.WarpPrecompileLogFilter}, nil, {common.Hash(warpID)}},
 		Addresses: []common.Address{warp.ContractAddress},
 		FromBlock: blockNum,
 		ToBlock:   blockNum,

tests/relay_message_api.go

@@ -69,7 +69,7 @@ func RelayMessageAPI(network interfaces.LocalNetwork) {
 
 	reqBody := api.RelayMessageRequest{
 		BlockchainID: subnetAInfo.BlockchainID.String(),
-		MessageID:    warpMessage.ID().Hex(),
+		MessageID:    warpMessage.ID().String(),
 		BlockNum:     receipt.BlockNumber.String(),
 	}