Update mercury e2e tests to support new mercury plugin and hmac auth

integration-tests/actions/mercury/report.go

@@ -0,0 +1,122 @@
+package mercury
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/ava-labs/coreth/accounts/abi"
+	"github.com/pkg/errors"
+	"github.com/rs/zerolog/log"
+)
+
+func getReportTypes() abi.Arguments {
+	mustNewType := func(t string) abi.Type {
+		result, err := abi.NewType(t, "", []abi.ArgumentMarshaling{})
+		if err != nil {
+			panic(fmt.Sprintf("Unexpected error during abi.NewType: %s", err))
+		}
+		return result
+	}
+	return abi.Arguments([]abi.Argument{
+		{Name: "feedId", Type: mustNewType("bytes32")},
+		{Name: "observationsTimestamp", Type: mustNewType("uint32")},
+		{Name: "benchmarkPrice", Type: mustNewType("int192")},
+		{Name: "bid", Type: mustNewType("int192")},
+		{Name: "ask", Type: mustNewType("int192")},
+		{Name: "currentBlockNum", Type: mustNewType("uint64")},
+		{Name: "currentBlockHash", Type: mustNewType("bytes32")},
+		{Name: "validFromBlockNum", Type: mustNewType("uint64")},
+	})
+}
+
+var ReportTypes = getReportTypes()
+
+func ValidateReport(reportBlob []byte) error {
+	r := map[string]interface{}{}
+	err := ReportTypes.UnpackIntoMap(r, []byte(reportBlob))
+	if err != nil {
+		return err
+	}
+
+	feedIdInterface, ok := r["feedId"]
+	if !ok {
+		return errors.Errorf("unpacked report has no 'feedId'")
+	}
+	feedID, ok := feedIdInterface.([32]byte)
+	if !ok {
+		return errors.Errorf("cannot cast feedId to [32]byte, type is %T", feedID)
+	}
+	log.Trace().Str("FeedID", string(feedID[:])).Msg("Feed ID")
+
+	benchmarkPriceInterface, ok := r["benchmarkPrice"]
+	if !ok {
+		return errors.Errorf("unpacked report has no 'benchmarkPrice'")
+	}
+	benchmarkPrice, ok := benchmarkPriceInterface.(*big.Int)
+	if !ok {
+		return errors.Errorf("cannot cast 'benchmarkPrice' to *big.Int, type is %T", benchmarkPrice)
+	}
+	log.Trace().Int64("benchmarkPrice", benchmarkPrice.Int64()).Msg("Benchmark price")
+
+	bidInterface, ok := r["bid"]
+	if !ok {
+		return errors.Errorf("unpacked report has no 'bid'")
+	}
+	bidPrice, ok := bidInterface.(*big.Int)
+	if !ok {
+		return errors.Errorf("cannot cast 'bid' to *big.Int, type is %T", bidPrice)
+	}
+	log.Trace().Int64("bid", benchmarkPrice.Int64()).Msg("Bid price")
+
+	askInterface, ok := r["ask"]
+	if !ok {
+		return errors.Errorf("unpacked report has no 'ask'")
+	}
+	askPrice, ok := askInterface.(*big.Int)
+	if !ok {
+		return errors.Errorf("cannot cast 'bid' to *big.Int, type is %T", askPrice)
+	}
+	log.Trace().Int64("ask", benchmarkPrice.Int64()).Msg("Ask price")
+
+	currentBlockNumInterface, ok := r["currentBlockNum"]
+	if !ok {
+		return errors.Errorf("unpacked report has no 'currentBlockNum'")
+	}
+	currentBlockNumber, ok := currentBlockNumInterface.(uint64)
+	if !ok {
+		return errors.Errorf("cannot cast 'currentBlockNum' to uint64, type is %T", currentBlockNumber)
+	}
+	log.Trace().Uint64("currentBlockNumber", currentBlockNumber).Msg("Observation current block number")
+
+	validFromBlockNumInterface, ok := r["validFromBlockNum"]
+	if !ok {
+		return errors.Errorf("unpacked report has no 'validFromBlockNum'")
+	}
+	validFromBlockNum, ok := validFromBlockNumInterface.(uint64)
+	if !ok {
+		return errors.Errorf("cannot cast 'validFromBlockNum' to uint64, type is %T", validFromBlockNum)
+	}
+	log.Trace().Uint64("validFromBlockNum", currentBlockNumber).Msg("Valid from block number")
+
+	currentBlockHashInterface, ok := r["currentBlockHash"]
+	if !ok {
+		return errors.Errorf("unpacked report has no 'currentBlockHash'")
+	}
+	currentBlockHash, ok := currentBlockHashInterface.([32]uint8)
+	if !ok {
+		return errors.Errorf("cannot cast 'currentBlockHash' to uint64, type is %v", currentBlockHash)
+	}
+	log.Trace().Any("currentBlockHash", currentBlockHash).Msg("currentBlockHash")
+
+	observationsTimestampInterface, ok := r["observationsTimestamp"]
+	if !ok {
+		return errors.Errorf("unpacked report has no 'observationsTimestamp'")
+	}
+	observationsTimestamp, ok := observationsTimestampInterface.(uint32)
+	if !ok {
+		return errors.Errorf("cannot cast observationsTimestamp to uint32, type is %T", observationsTimestamp)
+	}
+	log.Trace().Uint32("Timestamp", observationsTimestamp).Msg("Observation timestamp")
+
+	return nil
+}

integration-tests/client/chainlink.go

@@ -92,6 +92,7 @@ func (c *Chainlink) MustCreateJob(spec JobSpec) (*Job, error) {
 func (c *Chainlink) CreateJob(spec JobSpec) (*Job, *http.Response, error) {
 	job := &Job{}
 	specString, err := spec.String()
+	log.Info().Msgf("Creating job spec: %s", specString)
 	if err != nil {
 		return nil, nil, err
 	}

integration-tests/client/mercury_server.go

@@ -1,40 +1,163 @@
 package client
 
 import (
+	"context"
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
 	"net/http"
 	"strconv"
+	"time"
 
 	"github.com/go-resty/resty/v2"
+	"github.com/rs/zerolog/log"
+	"nhooyr.io/websocket"
 )
 
 type GetReportsResult struct {
 	ChainlinkBlob string `json:"chainlinkBlob"`
 }
 
+type User struct {
+	Id        string `json:"id"`
+	Secret    string `json:"secret" db:"secret"`
+	Role      string `json:"role" db:"role"` // 0 = user, 1 = admin
+	Disabled  bool   `json:"disabled" db:"disabled"`
+	CreatedAt string `json:"createdAt" db:"created_at"`
+	UpdatedAt string `json:"updatedAt" db:"updated_at"`
+}
+
 type MercuryServer struct {
 	URL       string
+	UserId    string
+	UserKey   string
 	APIClient *resty.Client
 }
 
-func NewMercuryServer(url string) *MercuryServer {
+// Create new mercury server client for userId and userKey that are used for HMAC authentication
+func NewMercuryServerClient(url string, userId string, userKey string) *MercuryServer {
 	rc := resty.New().SetBaseURL(url)
 	return &MercuryServer{
 		URL:       url,
 		APIClient: rc,
+		UserId:    userId,
+		UserKey:   userKey,
 	}
 }
 
-func (ms *MercuryServer) GetReports(feedIDStr string, blockNumber uint64) (*GetReportsResult, *http.Response, error) {
-	result := &GetReportsResult{}
-	resp, err := ms.APIClient.R().
-		SetPathParams(map[string]string{
-			"feedIDStr":     feedIDStr,
-			"L2Blocknumber": strconv.FormatUint(blockNumber, 10),
-		}).
+func (s *MercuryServer) DialWS() (*websocket.Conn, *http.Response, error) {
+	timestamp := genReqTimestamp()
+	hmacSignature := genHmacSignature("GET", "/ws", []byte{}, []byte(s.UserKey), s.UserId, timestamp)
+	return websocket.Dial(context.Background(), fmt.Sprintf("%s/ws", s.URL), &websocket.DialOptions{
+		HTTPHeader: http.Header{
+			"Authorization":                    []string{s.UserId},
+			"X-Authorization-Timestamp":        []string{timestamp},
+			"X-Authorization-Signature-SHA256": []string{hmacSignature},
+		},
+	})
+}
+
+func (s *MercuryServer) CallGet(path string) (map[string]interface{}, *http.Response, error) {
+	timestamp := genReqTimestamp()
+	hmacSignature := genHmacSignature("GET", path, []byte{}, []byte(s.UserKey), s.UserId, timestamp)
+	result := map[string]interface{}{}
+	resp, err := s.APIClient.R().
+		SetHeader("Authorization", s.UserId).
+		SetHeader("X-Authorization-Timestamp", timestamp).
+		SetHeader("X-Authorization-Signature-SHA256", hmacSignature).
 		SetResult(&result).
-		Get("/client?feedIDStr={feedIDStr}&L2Blocknumber={L2Blocknumber}")
+		Get(path)
 	if err != nil {
 		return nil, nil, err
 	}
+	return result, resp.RawResponse, nil
+}
+
+// Add new user with "admin" or "user" role
+func (s *MercuryServer) AddUser(newUserSecret string, newUserRole string, newUserDisabled bool) (*User, *http.Response, error) {
+	request := map[string]interface{}{
+		"secret":   newUserSecret,
+		"role":     newUserRole,
+		"disabled": newUserDisabled,
+	}
+	result := struct {
+		User User
+	}{}
+	path := "/admin/user"
+	timestamp := genReqTimestamp()
+	b, _ := json.Marshal(request)
+	hmacSignature := genHmacSignature("POST", path, b, []byte(s.UserKey), s.UserId, timestamp)
+	resp, err := s.APIClient.R().
+		SetHeader("Authorization", s.UserId).
+		SetHeader("X-Authorization-Timestamp", timestamp).
+		SetHeader("X-Authorization-Signature-SHA256", hmacSignature).
+		SetBody(request).
+		SetResult(result).
+		Post(path)
+	if err != nil {
+		return nil, nil, err
+	}
+	return &result.User, resp.RawResponse, err
+}
+
+// Need admin role
+func (s *MercuryServer) GetUsers() (*[]User, *http.Response, error) {
+	var result []User
+	path := "/admin/user"
+	timestamp := genReqTimestamp()
+	hmacSignature := genHmacSignature("GET", path, []byte{}, []byte(s.UserKey), s.UserId, timestamp)
+	resp, err := s.APIClient.R().
+		SetHeader("Accept", "application/json").
+		SetHeader("Authorization", s.UserId).
+		SetHeader("X-Authorization-Timestamp", timestamp).
+		SetHeader("X-Authorization-Signature-SHA256", hmacSignature).
+		SetResult(&result).
+		Get(path)
+	if err != nil {
+		return nil, nil, err
+	}
+	return &result, resp.RawResponse, err
+}
+
+func (s *MercuryServer) GetReports(feedIDStr string, blockNumber uint64) (*GetReportsResult, *http.Response, error) {
+	result := &GetReportsResult{}
+	path := fmt.Sprintf("/client?feedIDStr=%s&L2Blocknumber=%d", feedIDStr, blockNumber)
+	timestamp := genReqTimestamp()
+	hmacSignature := genHmacSignature("GET", path, []byte{}, []byte(s.UserKey), s.UserId, timestamp)
+	resp, err := s.APIClient.R().
+		SetHeader("Accept", "application/json").
+		SetHeader("Authorization", s.UserId).
+		SetHeader("X-Authorization-Timestamp", timestamp).
+		SetHeader("X-Authorization-Signature-SHA256", hmacSignature).
+		SetResult(&result).
+		Get(path)
+	if err != nil {
+		return nil, resp.RawResponse, err
+	}
 	return result, resp.RawResponse, err
 }
+
+func genReqTimestamp() string {
+	// The timestamp of the request. This is used to prevent replay attacks.
+	// The timestamp should be within 5 seconds of the server's time (by default).
+	// The server will reject requests with timestamps in the future.
+	return strconv.FormatInt(time.Now().UTC().UnixMilli(), 10)
+}
+
+func genHmacSignature(method string, path string, body []byte, secret []byte, clientId string, timestamp string) string {
+	// Get the hash for the body
+	bodyHash := sha256.New()
+	bodyHash.Write(body)
+	bodyHashString := hex.EncodeToString(bodyHash.Sum(nil))
+
+	// Generate the message to be signed
+	message := fmt.Sprintf("%s %s %s %s %s", method, path, bodyHashString, clientId, timestamp)
+	log.Debug().Msgf("message: %s", message)
+
+	// Generate the signature
+	signedMessage := hmac.New(sha256.New, secret)
+	signedMessage.Write([]byte(message))
+	return hex.EncodeToString(signedMessage.Sum(nil))
+}

integration-tests/contracts/contract_deployer.go

@@ -75,8 +75,11 @@ type ContractDeployer interface {
 	DeployStaking(params ethereum2.StakingPoolConstructorParams) (Staking, error)
 	DeployBatchBlockhashStore(blockhashStoreAddr string) (BatchBlockhashStore, error)
 	DeployAtlasFunctions() (AtlasFunctions, error)
+	LoadVerifierProxy(address common.Address) (VerifierProxy, error)
 	DeployVerifierProxy(accessControllerAddr string) (VerifierProxy, error)
-	DeployVerifier(feedId [32]byte, verifierProxyAddr string) (Verifier, error)
+	LoadVerifier(address common.Address) (Verifier, error)
+	DeployVerifier(verifierProxyAddr string) (Verifier, error)
+	LoadExchanger(address common.Address) (Exchanger, error)
 	DeployExchanger(verifierProxyAddr string, lookupURL string, maxDelay uint8) (Exchanger, error)
 }