feat: signing api

api/handlers/signing.go

@@ -0,0 +1,78 @@
+package handlers
+
+import (
+	"encoding/json"
+	"fmt"
+	"math/big"
+	"net/http"
+
+	across "github.com/sprintertech/sprinter-signing/chains/evm/message"
+	"github.com/sygmaprotocol/sygma-core/relayer/message"
+)
+
+type SigningBody struct {
+	DepositId *big.Int `json:"depositId"`
+	ChainId   uint64   `json:"chainId"`
+}
+
+type SigningHandler struct {
+	msgChan chan []*message.Message
+	chains  map[uint64]struct{}
+}
+
+func NewSigningHandler(msgChan chan []*message.Message, chains map[uint64]struct{}) *SigningHandler {
+	return &SigningHandler{
+		msgChan: msgChan,
+		chains:  chains,
+	}
+}
+
+// HandleSigning sends a message to the across message handler and returns status code 202
+// if the deposit has been accepted for the signing process
+func (h *SigningHandler) HandleSigning(w http.ResponseWriter, r *http.Request) {
+	b := &SigningBody{}
+	d := json.NewDecoder(r.Body)
+	err := d.Decode(b)
+	if err != nil {
+		JSONError(w, fmt.Sprintf("invalid request body: %s", err), http.StatusBadRequest)
+		return
+	}
+
+	err = h.validate(b)
+	if err != nil {
+		JSONError(w, fmt.Sprintf("invalid request body: %s", err), http.StatusBadRequest)
+		return
+	}
+
+	errChn := make(chan error, 1)
+	am := across.NewAcrossMessage(0, b.ChainId, across.AcrossData{
+		DepositId: b.DepositId,
+		ErrChn:    errChn,
+	})
+	h.msgChan <- []*message.Message{am}
+
+	err = <-errChn
+	if err != nil {
+		JSONError(w, fmt.Sprintf("Singing failed: %s", err), http.StatusInternalServerError)
+		return
+	}
+
+	w.WriteHeader(http.StatusAccepted)
+}
+
+func (h *SigningHandler) validate(b *SigningBody) error {
+	if b.DepositId == nil {
+		return fmt.Errorf("missing field 'depositId'")
+	}
+
+	if b.ChainId == 0 {
+		return fmt.Errorf("missing field 'chainId'")
+	}
+
+	_, ok := h.chains[b.ChainId]
+	if !ok {
+		return fmt.Errorf("chain '%d' not supported", b.ChainId)
+	}
+
+	return nil
+}

api/handlers/signing_test.go

@@ -0,0 +1,153 @@
+package handlers_test
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"math/big"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/sprintertech/sprinter-signing/api/handlers"
+	across "github.com/sprintertech/sprinter-signing/chains/evm/message"
+	"github.com/stretchr/testify/suite"
+	"github.com/sygmaprotocol/sygma-core/relayer/message"
+	"go.uber.org/mock/gomock"
+)
+
+type SigningHandlerTestSuite struct {
+	suite.Suite
+
+	handler *handlers.SigningHandler
+	msgChn  chan []*message.Message
+}
+
+func TestRunSigningHandlerTestSuite(t *testing.T) {
+	suite.Run(t, new(SigningHandlerTestSuite))
+}
+
+func (s *SigningHandlerTestSuite) SetupTest() {
+	ctrl := gomock.NewController(s.T())
+	defer ctrl.Finish()
+
+	chains := make(map[uint64]struct{})
+	chains[1] = struct{}{}
+
+	s.msgChn = make(chan []*message.Message, 1)
+	s.handler = handlers.NewSigningHandler(s.msgChn, chains)
+}
+
+func (s *SigningHandlerTestSuite) Test_HandleSigning_MissingDepositID() {
+	input := handlers.SigningBody{
+		ChainId: 1,
+	}
+	body, _ := json.Marshal(input)
+
+	req := httptest.NewRequest(http.MethodPost, "/signing", bytes.NewReader(body))
+	req.Header.Set("Content-Type", "application/json")
+
+	recorder := httptest.NewRecorder()
+
+	go func() {
+		msg := <-s.msgChn
+		ad := msg[0].Data.(across.AcrossData)
+		ad.ErrChn <- fmt.Errorf("error handling message")
+	}()
+
+	s.handler.HandleSigning(recorder, req)
+
+	s.Equal(http.StatusBadRequest, recorder.Code)
+}
+
+func (s *SigningHandlerTestSuite) Test_HandleSigning_MissingChainID() {
+	input := handlers.SigningBody{
+		DepositId: big.NewInt(1000),
+	}
+	body, _ := json.Marshal(input)
+
+	req := httptest.NewRequest(http.MethodPost, "/signing", bytes.NewReader(body))
+	req.Header.Set("Content-Type", "application/json")
+
+	recorder := httptest.NewRecorder()
+
+	go func() {
+		msg := <-s.msgChn
+		ad := msg[0].Data.(across.AcrossData)
+		ad.ErrChn <- fmt.Errorf("error handling message")
+	}()
+
+	s.handler.HandleSigning(recorder, req)
+
+	s.Equal(http.StatusBadRequest, recorder.Code)
+}
+
+func (s *SigningHandlerTestSuite) Test_HandleSigning_ChainNotSupported() {
+	input := handlers.SigningBody{
+		ChainId:   2,
+		DepositId: big.NewInt(1000),
+	}
+	body, _ := json.Marshal(input)
+
+	req := httptest.NewRequest(http.MethodPost, "/signing", bytes.NewReader(body))
+	req.Header.Set("Content-Type", "application/json")
+
+	recorder := httptest.NewRecorder()
+
+	go func() {
+		msg := <-s.msgChn
+		ad := msg[0].Data.(across.AcrossData)
+		ad.ErrChn <- fmt.Errorf("error handling message")
+	}()
+
+	s.handler.HandleSigning(recorder, req)
+
+	s.Equal(http.StatusBadRequest, recorder.Code)
+}
+
+func (s *SigningHandlerTestSuite) Test_HandleSigning_ErrorHandlingMessage() {
+	input := handlers.SigningBody{
+		ChainId:   1,
+		DepositId: big.NewInt(1000),
+	}
+	body, _ := json.Marshal(input)
+
+	req := httptest.NewRequest(http.MethodPost, "/signing", bytes.NewReader(body))
+	req.Header.Set("Content-Type", "application/json")
+
+	recorder := httptest.NewRecorder()
+
+	go func() {
+		msg := <-s.msgChn
+		ad := msg[0].Data.(across.AcrossData)
+		ad.ErrChn <- fmt.Errorf("error handling message")
+	}()
+
+	s.handler.HandleSigning(recorder, req)
+
+	s.Equal(http.StatusInternalServerError, recorder.Code)
+}
+
+func (s *SigningHandlerTestSuite) Test_HandleSigning_Success() {
+	input := handlers.SigningBody{
+		ChainId:   1,
+		DepositId: big.NewInt(1000),
+	}
+	body, _ := json.Marshal(input)
+
+	req := httptest.NewRequest(http.MethodPost, "/signing", bytes.NewReader(body))
+	req.Header.Set("Content-Type", "application/json")
+
+	recorder := httptest.NewRecorder()
+
+	go func() {
+		msg := <-s.msgChn
+		ad := msg[0].Data.(across.AcrossData)
+		ad.ErrChn <- nil
+	}()
+
+	s.handler.HandleSigning(recorder, req)
+
+	fmt.Println(recorder.Body.String())
+	s.Equal(http.StatusAccepted, recorder.Code)
+}

api/handlers/util.go

@@ -0,0 +1,13 @@
+package handlers
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+func JSONError(w http.ResponseWriter, err interface{}, code int) {
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	w.Header().Set("X-Content-Type-Options", "nosniff")
+	w.WriteHeader(code)
+	_ = json.NewEncoder(w).Encode(err)
+}

api/server.go

@@ -0,0 +1,40 @@
+package api
+
+import (
+	"context"
+	"net/http"
+	"time"
+
+	"github.com/rs/zerolog/log"
+	"github.com/sprintertech/sprinter-signing/api/handlers"
+)
+
+func Serve(
+	ctx context.Context,
+	addr string,
+	signingHandler *handlers.SigningHandler,
+) {
+	mux := http.NewServeMux()
+	mux.HandleFunc("POST /signing", signingHandler.HandleSigning)
+
+	server := &http.Server{
+		Addr: addr,
+	}
+	go func() {
+		log.Info().Msgf("Starting server on %s", addr)
+		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			panic(err)
+		}
+	}()
+
+	<-ctx.Done()
+	shutdownCtx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	err := server.Shutdown(shutdownCtx)
+	if err != nil {
+		log.Err(err).Msgf("Error shutting down server")
+	} else {
+		log.Info().Msgf("Server shut down gracefully.")
+	}
+}