feat: signing api (#13)

* Allow coordinator to be set manually

* Add manual coordinator test

* Implement across message handler

* Send signature to all relayers

* Implement signature cache to store generated signatures

* Speed up process coordination

* Implement signature cache to store  generated signatures

* Add signature cache tests

* Allow for coordinator to notify other relayers of an across message

* Reduce tss timeout

* Implement calculation of the unlock hash that matches on-chain implementation

* Add across message handler tests

* Update mocks to maintained version

* Fix test race condition

* Convert abi to constant

* Use source chain id property from across data

* Use message destination as across deposit source

* Use coordinator from the host in message handler

* Send across message result over the err chanel

* Return api errors as json

* Implement api serve function

* Add signing handler tests

* Ignore valid json encode errors

* Remove print

* Bump cache action

* Use a custom big.Int type that decode big int from string

* Add read timeout

* Add custom lint configuration

* Remove messy linters

* Lint

* Remove extra nolint

* Remove linter errors

Author: mpetrun5

.github/workflows/test.yml

@@ -24,7 +24,7 @@ jobs:
           go-version: ${{ matrix.go-version }}
       - name: Checkout code
         uses: actions/checkout@v2
-      - uses: actions/cache@v2
+      - uses: actions/cache@v4
         with:
           path: ~/go/pkg/mod
           key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}

.golangci.yml

@@ -0,0 +1,32 @@
+# Refer to golangci-lint's example config file for more options and information:
+# https://github.com/golangci/golangci-lint/blob/master/.golangci.reference.yml
+
+run:
+  timeout: 5m
+  modules-download-mode: readonly
+  exclude-dirs:
+    - vendor
+    - third_party
+
+linters:
+  enable:
+    - errcheck
+    - gosimple
+    - goimports
+    - govet
+    - staticcheck
+    - unused
+    - ineffassign
+    - bodyclose
+    - gocognit
+    - godox
+    - gosec
+    - misspell
+    - nilerr
+    - reassign
+    - wastedassign
+    - whitespace
+
+issues:
+  max-issues-per-linter: 0
+  max-same-issues: 0

api/handlers/signing.go

@@ -0,0 +1,77 @@
+package handlers
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	across "github.com/sprintertech/sprinter-signing/chains/evm/message"
+	"github.com/sygmaprotocol/sygma-core/relayer/message"
+)
+
+type SigningBody struct {
+	DepositId *BigInt `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.Int,
+		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,152 @@
+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: &handlers.BigInt{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: &handlers.BigInt{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: &handlers.BigInt{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: &handlers.BigInt{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)
+
+	s.Equal(http.StatusAccepted, recorder.Code)
+}

api/handlers/util.go

@@ -0,0 +1,38 @@
+package handlers
+
+import (
+	"encoding/json"
+	"fmt"
+	"math/big"
+	"net/http"
+	"strings"
+)
+
+type BigInt struct {
+	*big.Int
+}
+
+func (b *BigInt) UnmarshalJSON(data []byte) error {
+	if b.Int == nil {
+		b.Int = new(big.Int)
+	}
+
+	s := strings.Trim(string(data), "\"")
+	_, ok := b.Int.SetString(s, 10)
+	if !ok {
+		return fmt.Errorf("failed to parse big.Int from %s", s)
+	}
+
+	return nil
+}
+
+func (b *BigInt) MarshalJSON() ([]byte, error) {
+	return []byte(b.String()), nil
+}
+
+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,41 @@
+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,
+		ReadTimeout: 10 * time.Second,
+	}
+	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(ctx, 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.")
+	}
+}

chains/evm/config.go

@@ -74,6 +74,7 @@ func NewEVMConfig(chainConfig map[string]interface{}) (*EVMConfig, error) {
 		GeneralChainConfig: c.GeneralChainConfig,
 		Admin:              c.Admin,
 		LiqudityPool:       c.LiqudityPool,
+		// nolint:gosec
 		BlockRetryInterval: time.Duration(c.BlockRetryInterval) * time.Second,
 		BlockConfirmations: big.NewInt(c.BlockConfirmations),
 		BlockInterval:      big.NewInt(c.BlockInterval),