Get signature endpoint

handlers/handler.go

@@ -0,0 +1,60 @@
+// (c) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package handlers
+
+import (
+	"context"
+
+	"github.com/ava-labs/avalanchego/codec"
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/subnet-evm/handlers/stats"
+	"github.com/ava-labs/subnet-evm/metrics"
+	"github.com/ava-labs/subnet-evm/plugin/evm/message"
+	"github.com/ava-labs/subnet-evm/sync/handlers"
+	syncHandlers "github.com/ava-labs/subnet-evm/sync/handlers"
+	"github.com/ava-labs/subnet-evm/trie"
+)
+
+var _ message.RequestHandler = &networkHandler{}
+
+type networkHandler struct {
+	stateTrieLeafsRequestHandler *syncHandlers.LeafsRequestHandler
+	blockRequestHandler          *syncHandlers.BlockRequestHandler
+	codeRequestHandler           *syncHandlers.CodeRequestHandler
+	signatureRequestHandler      SignatureRequestHandler
+}
+
+// NewNetworkHandler constructs the handler for serving network requests.
+func NewNetworkHandler(
+	provider handlers.SyncDataProvider,
+	evmTrieDB *trie.Database,
+	networkCodec codec.Manager,
+) message.RequestHandler {
+	handlerStats := stats.NewHandlerStats(metrics.Enabled)
+	return &networkHandler{
+		// State sync handlers
+		stateTrieLeafsRequestHandler: syncHandlers.NewLeafsRequestHandler(evmTrieDB, provider, networkCodec, handlerStats),
+		blockRequestHandler:          syncHandlers.NewBlockRequestHandler(provider, networkCodec, handlerStats),
+		codeRequestHandler:           syncHandlers.NewCodeRequestHandler(evmTrieDB.DiskDB(), networkCodec, handlerStats),
+
+		// TODO: initialize actual signature request handler when warp is ready
+		signatureRequestHandler: &NoopSignatureRequestHandler{},
+	}
+}
+
+func (n networkHandler) HandleTrieLeafsRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, leafsRequest message.LeafsRequest) ([]byte, error) {
+	return n.stateTrieLeafsRequestHandler.OnLeafsRequest(ctx, nodeID, requestID, leafsRequest)
+}
+
+func (n networkHandler) HandleBlockRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, blockRequest message.BlockRequest) ([]byte, error) {
+	return n.blockRequestHandler.OnBlockRequest(ctx, nodeID, requestID, blockRequest)
+}
+
+func (n networkHandler) HandleCodeRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, codeRequest message.CodeRequest) ([]byte, error) {
+	return n.codeRequestHandler.OnCodeRequest(ctx, nodeID, requestID, codeRequest)
+}
+
+func (n networkHandler) HandleSignatureRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, signatureRequest message.SignatureRequest) ([]byte, error) {
+	return n.signatureRequestHandler.OnSignatureRequest(ctx, nodeID, requestID, signatureRequest)
+}

handlers/signature_request.go

@@ -0,0 +1,75 @@
+// (c) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package handlers
+
+import (
+	"context"
+	"time"
+
+	"github.com/ava-labs/avalanchego/codec"
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/subnet-evm/handlers/stats"
+	"github.com/ava-labs/subnet-evm/plugin/evm/message"
+	"github.com/ava-labs/subnet-evm/plugin/evm/warp"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+// SignatureRequestHandler is a peer.RequestHandler for message.SignatureRequest
+// serving requested BLS signature data
+type SignatureRequestHandler interface {
+	OnSignatureRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, signatureRequest message.SignatureRequest) ([]byte, error)
+}
+
+// signatureRequestHandler implements the SignatureRequestHandler interface
+type signatureRequestHandler struct {
+	backend warp.WarpBackend
+	codec   codec.Manager
+	stats   stats.SignatureRequestHandlerStats
+}
+
+func NewSignatureRequestHandler(backend warp.WarpBackend, codec codec.Manager, stats stats.SignatureRequestHandlerStats) SignatureRequestHandler {
+	return &signatureRequestHandler{
+		backend: backend,
+		codec:   codec,
+		stats:   stats,
+	}
+}
+
+// OnSignatureRequest handles message.SignatureRequest, and retrieves a warp signature for the requested message ID.
+// Never returns an error
+// Expects returned errors to be treated as FATAL
+// Returns empty response if signature is not found
+// Assumes ctx is active
+func (s *signatureRequestHandler) OnSignatureRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, signatureRequest message.SignatureRequest) ([]byte, error) {
+	startTime := time.Now()
+	s.stats.IncSignatureRequest()
+
+	// Always report signature request time
+	defer func() {
+		s.stats.UpdateSignatureRequestTime(time.Since(startTime))
+	}()
+
+	signature, err := s.backend.GetSignature(ctx, signatureRequest.MessageID)
+	if err != nil {
+		log.Debug("Unknown warp signature requested", "messageID", signatureRequest.MessageID)
+		s.stats.IncSignatureMiss()
+		return nil, nil
+	}
+
+	s.stats.IncSignatureHit()
+	response := message.SignatureResponse{Signature: signature}
+	responseBytes, err := s.codec.Marshal(message.Version, response)
+	if err != nil {
+		log.Warn("could not marshal SignatureResponse, dropping request", "nodeID", nodeID, "requestID", requestID, "err", err)
+		return nil, nil
+	}
+
+	return responseBytes, nil
+}
+
+type NoopSignatureRequestHandler struct{}
+
+func (s *NoopSignatureRequestHandler) OnSignatureRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, signatureRequest message.SignatureRequest) ([]byte, error) {
+	return nil, nil
+}

handlers/signature_request_test.go

@@ -0,0 +1,99 @@
+// (c) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package handlers
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/ava-labs/avalanchego/database/memdb"
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/avalanchego/snow"
+	"github.com/ava-labs/avalanchego/utils/crypto/bls"
+	"github.com/ava-labs/avalanchego/utils/hashing"
+	"github.com/ava-labs/avalanchego/vms/platformvm/teleporter"
+	"github.com/ava-labs/subnet-evm/handlers/stats"
+	"github.com/ava-labs/subnet-evm/plugin/evm/message"
+	"github.com/ava-labs/subnet-evm/plugin/evm/warp"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestSignatureHandler(t *testing.T) {
+	database := memdb.New()
+	snowCtx := snow.DefaultContextTest()
+	blsSecretKey, err := bls.NewSecretKey()
+	require.NoError(t, err)
+
+	snowCtx.TeleporterSigner = teleporter.NewSigner(blsSecretKey, snowCtx.ChainID)
+	warpBackend := warp.NewWarpBackend(snowCtx, database, 100)
+
+	msg, err := teleporter.NewUnsignedMessage(snowCtx.ChainID, snowCtx.CChainID, []byte("test"))
+	require.NoError(t, err)
+
+	messageID := hashing.ComputeHash256Array(msg.Bytes())
+	require.NoError(t, warpBackend.AddMessage(context.Background(), msg))
+	signature, err := warpBackend.GetSignature(context.Background(), messageID)
+	require.NoError(t, err)
+	unknownMessageID := ids.GenerateTestID()
+
+	mockHandlerStats := &stats.MockHandlerStats{}
+	signatureRequestHandler := NewSignatureRequestHandler(warpBackend, message.Codec, mockHandlerStats)
+
+	tests := map[string]struct {
+		setup       func() (request message.SignatureRequest, expectedResponse []byte)
+		verifyStats func(t *testing.T, stats *stats.MockHandlerStats)
+	}{
+		"normal": {
+			setup: func() (request message.SignatureRequest, expectedResponse []byte) {
+				return message.SignatureRequest{
+					MessageID: messageID,
+				}, signature[:]
+			},
+			verifyStats: func(t *testing.T, stats *stats.MockHandlerStats) {
+				assert.EqualValues(t, 1, mockHandlerStats.SignatureRequestCount)
+				assert.EqualValues(t, 1, mockHandlerStats.SignatureRequestHit)
+				assert.Greater(t, mockHandlerStats.SignatureRequestDuration, time.Duration(0))
+			},
+		},
+		"unknown": {
+			setup: func() (request message.SignatureRequest, expectedResponse []byte) {
+				return message.SignatureRequest{
+					MessageID: unknownMessageID,
+				}, nil
+			},
+			verifyStats: func(t *testing.T, stats *stats.MockHandlerStats) {
+				assert.EqualValues(t, 1, mockHandlerStats.SignatureRequestCount)
+				assert.EqualValues(t, 1, mockHandlerStats.SignatureRequestMiss)
+				assert.Greater(t, mockHandlerStats.SignatureRequestDuration, time.Duration(0))
+			},
+		},
+	}
+
+	for name, test := range tests {
+		// Reset stats before each test
+		mockHandlerStats.Reset()
+
+		t.Run(name, func(t *testing.T) {
+			request, expectedResponse := test.setup()
+			responseBytes, err := signatureRequestHandler.OnSignatureRequest(context.Background(), ids.GenerateTestNodeID(), 1, request)
+			assert.NoError(t, err)
+
+			// If the expected response is empty, assert that the handler returns an empty response and return early.
+			if len(expectedResponse) == 0 {
+				assert.Len(t, responseBytes, 0, "expected response to be empty")
+				return
+			}
+			var response message.SignatureResponse
+			_, err = message.Codec.Unmarshal(responseBytes, &response)
+			require.NoError(t, err, "error unmarshalling SignatureResponse")
+
+			var expectedSignature [bls.SignatureLen]byte
+			copy(expectedSignature[:], expectedResponse)
+			assert.Equal(t, expectedSignature, response.Signature)
+			test.verifyStats(t, mockHandlerStats)
+		})
+	}
+}