2022-11-23 04:06:29 -08:00
|
|
|
// package middleare contains all the middleware function to use in the API.
|
2022-11-17 07:37:29 -08:00
|
|
|
package middleware
|
|
|
|
|
|
|
|
import (
|
2022-11-23 04:06:29 -08:00
|
|
|
"fmt"
|
2023-03-07 11:25:42 -08:00
|
|
|
"regexp"
|
2022-11-17 07:37:29 -08:00
|
|
|
"strconv"
|
2023-03-07 11:25:42 -08:00
|
|
|
"strings"
|
|
|
|
"time"
|
2022-11-17 07:37:29 -08:00
|
|
|
|
2023-03-21 12:12:23 -07:00
|
|
|
solana "github.com/gagliardetto/solana-go"
|
2022-11-17 07:37:29 -08:00
|
|
|
"github.com/gofiber/fiber/v2"
|
2022-11-23 04:06:29 -08:00
|
|
|
"github.com/pkg/errors"
|
|
|
|
"github.com/wormhole-foundation/wormhole-explorer/api/response"
|
2023-02-28 12:50:23 -08:00
|
|
|
"github.com/wormhole-foundation/wormhole-explorer/api/types"
|
2023-03-21 12:12:23 -07:00
|
|
|
sdk "github.com/wormhole-foundation/wormhole/sdk/vaa"
|
2022-11-23 04:06:29 -08:00
|
|
|
"go.uber.org/zap"
|
2022-11-17 07:37:29 -08:00
|
|
|
)
|
|
|
|
|
2022-11-23 04:06:29 -08:00
|
|
|
// ExtractChainID get chain parameter from route path.
|
2023-03-21 12:12:23 -07:00
|
|
|
func ExtractChainID(c *fiber.Ctx, l *zap.Logger) (sdk.ChainID, error) {
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2022-11-17 07:37:29 -08:00
|
|
|
chain, err := c.ParamsInt("chain")
|
|
|
|
if err != nil {
|
2022-11-23 04:06:29 -08:00
|
|
|
requestID := fmt.Sprintf("%v", c.Locals("requestid"))
|
2023-02-09 09:28:39 -08:00
|
|
|
l.Error("failed to get chain parameter",
|
|
|
|
zap.Error(err),
|
|
|
|
zap.Int("chain", chain),
|
|
|
|
zap.String("requestID", requestID),
|
|
|
|
)
|
2022-11-23 04:06:29 -08:00
|
|
|
|
2023-03-21 12:12:23 -07:00
|
|
|
return sdk.ChainIDUnset, response.NewInvalidParamError(c, "WRONG CHAIN ID", errors.WithStack(err))
|
2022-11-17 07:37:29 -08:00
|
|
|
}
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2023-03-21 12:12:23 -07:00
|
|
|
return sdk.ChainID(chain), nil
|
2022-11-17 07:37:29 -08:00
|
|
|
}
|
|
|
|
|
2023-03-21 12:12:23 -07:00
|
|
|
// ExtractEmitterAddr parses the emitter address from the request path.
|
|
|
|
//
|
|
|
|
// When the parameter `chainIdHint` is not nil, this function will attempt to parse the
|
|
|
|
// native address format of the specified chain.
|
|
|
|
//
|
|
|
|
// The fallback behavior is to parse the address according to the Wormhole hex format.
|
|
|
|
func ExtractEmitterAddr(c *fiber.Ctx, l *zap.Logger, chainIdHint *sdk.ChainID) (*types.Address, error) {
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2022-11-17 07:37:29 -08:00
|
|
|
emitterStr := c.Params("emitter")
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2023-03-21 12:12:23 -07:00
|
|
|
// If the chain ID is Solana, attempt to parse the emitter as a Solana address.
|
|
|
|
if chainIdHint != nil && *chainIdHint == sdk.ChainIDSolana {
|
|
|
|
|
|
|
|
// If the address fails to parse, just fall back to the Wormhole format.
|
|
|
|
sig, err := solana.PublicKeyFromBase58(emitterStr)
|
|
|
|
if err == nil {
|
|
|
|
// This step is not expected to fail, since Solana and Wormhole addresses have the same size.
|
|
|
|
// However, if it does, we log the error.
|
|
|
|
emitter, err := types.BytesToAddress(sig[:])
|
|
|
|
if err == nil {
|
|
|
|
return emitter, nil
|
|
|
|
}
|
|
|
|
l.Warn("failed to convert Solana address to Wormhole address",
|
|
|
|
zap.String("emitterAddress", emitterStr),
|
|
|
|
zap.Error(err),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Attempt to parse the address according to the Wormhole hex format.
|
2023-02-28 12:50:23 -08:00
|
|
|
emitter, err := types.StringToAddress(emitterStr)
|
2022-11-17 07:37:29 -08:00
|
|
|
if err != nil {
|
2022-11-23 04:06:29 -08:00
|
|
|
requestID := fmt.Sprintf("%v", c.Locals("requestid"))
|
2023-03-21 12:12:23 -07:00
|
|
|
l.Error("failed to convert emitter to wormhole address",
|
2023-02-09 09:28:39 -08:00
|
|
|
zap.Error(err),
|
|
|
|
zap.String("emitterStr", emitterStr),
|
|
|
|
zap.String("requestID", requestID),
|
|
|
|
)
|
2022-11-23 04:06:29 -08:00
|
|
|
return nil, response.NewInvalidParamError(c, "MALFORMED EMITTER_ADDR", errors.WithStack(err))
|
2022-11-17 07:37:29 -08:00
|
|
|
}
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2023-02-28 12:50:23 -08:00
|
|
|
return emitter, nil
|
2022-11-17 07:37:29 -08:00
|
|
|
}
|
|
|
|
|
2022-11-23 04:06:29 -08:00
|
|
|
// ExtractSequence get sequence parameter from route path.
|
|
|
|
func ExtractSequence(c *fiber.Ctx, l *zap.Logger) (uint64, error) {
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2022-11-17 07:37:29 -08:00
|
|
|
sequence := c.Params("sequence")
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2022-11-17 07:37:29 -08:00
|
|
|
seq, err := strconv.ParseUint(sequence, 10, 64)
|
|
|
|
if err != nil {
|
2022-11-23 04:06:29 -08:00
|
|
|
requestID := fmt.Sprintf("%v", c.Locals("requestid"))
|
2023-02-09 09:28:39 -08:00
|
|
|
l.Error("failed to get sequence parameter",
|
|
|
|
zap.Error(err),
|
|
|
|
zap.String("sequence", sequence),
|
|
|
|
zap.String("requestID", requestID),
|
|
|
|
)
|
2022-11-23 04:06:29 -08:00
|
|
|
return 0, response.NewInvalidParamError(c, "MALFORMED SEQUENCE NUMBER", errors.WithStack(err))
|
2022-11-17 07:37:29 -08:00
|
|
|
}
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2022-11-17 07:37:29 -08:00
|
|
|
return seq, nil
|
|
|
|
}
|
|
|
|
|
2022-11-23 04:06:29 -08:00
|
|
|
// ExtractGuardianAddress get guardian address from route path.
|
2023-02-28 12:50:23 -08:00
|
|
|
func ExtractGuardianAddress(c *fiber.Ctx, l *zap.Logger) (*types.Address, error) {
|
2023-02-09 09:28:39 -08:00
|
|
|
|
|
|
|
// read the address from query params
|
|
|
|
tmp := c.Params("guardian_address")
|
|
|
|
if tmp == "" {
|
2023-02-28 12:50:23 -08:00
|
|
|
return nil, response.NewInvalidParamError(c, "MALFORMED GUARDIAN ADDR", nil)
|
2022-11-17 07:37:29 -08:00
|
|
|
}
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2023-02-28 12:50:23 -08:00
|
|
|
// validate the address
|
|
|
|
guardianAddress, err := types.StringToAddress(tmp)
|
2023-02-09 09:28:39 -08:00
|
|
|
if err != nil {
|
|
|
|
requestID := fmt.Sprintf("%v", c.Locals("requestid"))
|
|
|
|
l.Error("failed to decode guardian address",
|
|
|
|
zap.Error(err),
|
|
|
|
zap.String("requestID", requestID),
|
|
|
|
)
|
2023-02-28 12:50:23 -08:00
|
|
|
return nil, response.NewInvalidParamError(c, "MALFORMED GUARDIAN ADDR", errors.WithStack(err))
|
2023-02-09 09:28:39 -08:00
|
|
|
}
|
|
|
|
|
2023-02-28 12:50:23 -08:00
|
|
|
return guardianAddress, nil
|
2022-11-17 07:37:29 -08:00
|
|
|
}
|
|
|
|
|
2022-11-23 04:06:29 -08:00
|
|
|
// ExtractVAAParams get VAA chain, address from route path.
|
2023-03-21 12:12:23 -07:00
|
|
|
func ExtractVAAChainIDEmitter(c *fiber.Ctx, l *zap.Logger) (sdk.ChainID, *types.Address, error) {
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2022-11-23 04:06:29 -08:00
|
|
|
chainID, err := ExtractChainID(c, l)
|
|
|
|
if err != nil {
|
2023-03-21 12:12:23 -07:00
|
|
|
return sdk.ChainIDUnset, nil, err
|
2022-11-23 04:06:29 -08:00
|
|
|
}
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2023-03-21 12:12:23 -07:00
|
|
|
address, err := ExtractEmitterAddr(c, l, &chainID)
|
2022-11-23 04:06:29 -08:00
|
|
|
if err != nil {
|
|
|
|
return chainID, nil, err
|
|
|
|
}
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2022-11-23 04:06:29 -08:00
|
|
|
return chainID, address, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// ExtractVAAParams get VAAA chain, address and sequence from route path.
|
2023-03-21 12:12:23 -07:00
|
|
|
func ExtractVAAParams(c *fiber.Ctx, l *zap.Logger) (sdk.ChainID, *types.Address, uint64, error) {
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2022-11-23 04:06:29 -08:00
|
|
|
chainID, err := ExtractChainID(c, l)
|
2022-11-17 07:37:29 -08:00
|
|
|
if err != nil {
|
2023-03-21 12:12:23 -07:00
|
|
|
return sdk.ChainIDUnset, nil, 0, err
|
2022-11-17 07:37:29 -08:00
|
|
|
}
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2023-03-21 12:12:23 -07:00
|
|
|
address, err := ExtractEmitterAddr(c, l, &chainID)
|
2022-11-17 07:37:29 -08:00
|
|
|
if err != nil {
|
|
|
|
return chainID, nil, 0, err
|
|
|
|
}
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2022-11-23 04:06:29 -08:00
|
|
|
seq, err := ExtractSequence(c, l)
|
2022-11-17 07:37:29 -08:00
|
|
|
if err != nil {
|
|
|
|
return chainID, address, 0, err
|
|
|
|
}
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2022-11-17 07:37:29 -08:00
|
|
|
return chainID, address, seq, nil
|
|
|
|
}
|
2022-11-23 04:06:29 -08:00
|
|
|
|
|
|
|
// ExtractObservationSigner get signer from route path.
|
2023-03-21 12:12:23 -07:00
|
|
|
func ExtractObservationSigner(c *fiber.Ctx, l *zap.Logger) (*sdk.Address, error) {
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2022-11-23 04:06:29 -08:00
|
|
|
signer := c.Params("signer")
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2023-03-21 12:12:23 -07:00
|
|
|
signerAddr, err := sdk.StringToAddress(signer)
|
2022-11-23 04:06:29 -08:00
|
|
|
if err != nil {
|
|
|
|
requestID := fmt.Sprintf("%v", c.Locals("requestid"))
|
2023-02-09 09:28:39 -08:00
|
|
|
l.Error("failed to covert signer to address",
|
|
|
|
zap.Error(err),
|
|
|
|
zap.String("signer", signer),
|
|
|
|
zap.String("requestID", requestID),
|
|
|
|
)
|
2022-11-23 04:06:29 -08:00
|
|
|
return nil, response.NewInvalidParamError(c, "MALFORMED SIGNER", errors.WithStack(err))
|
|
|
|
}
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2022-11-23 04:06:29 -08:00
|
|
|
return &signerAddr, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// ExtractObservationHash get a hash from route path.
|
|
|
|
func ExtractObservationHash(c *fiber.Ctx, l *zap.Logger) (string, error) {
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2022-11-23 04:06:29 -08:00
|
|
|
hash := c.Params("hash")
|
|
|
|
if hash == "" {
|
|
|
|
return "", response.NewInvalidParamError(c, "MALFORMED HASH", nil)
|
|
|
|
}
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2022-11-23 04:06:29 -08:00
|
|
|
return hash, nil
|
|
|
|
}
|
2023-01-26 06:54:41 -08:00
|
|
|
|
|
|
|
// GetTxHash get txHash parameter from query param.
|
2023-03-21 12:12:23 -07:00
|
|
|
func GetTxHash(c *fiber.Ctx, l *zap.Logger) (*sdk.Address, error) {
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2023-01-26 06:54:41 -08:00
|
|
|
txHash := c.Query("txHash")
|
|
|
|
if txHash == "" {
|
|
|
|
return nil, nil
|
|
|
|
}
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2023-03-21 12:12:23 -07:00
|
|
|
txHashAddr, err := sdk.StringToAddress(txHash)
|
2023-01-26 06:54:41 -08:00
|
|
|
if err != nil {
|
|
|
|
requestID := fmt.Sprintf("%v", c.Locals("requestid"))
|
2023-02-09 09:28:39 -08:00
|
|
|
l.Error("failed to covert txHash to address",
|
|
|
|
zap.Error(err),
|
|
|
|
zap.String("txHash", txHash),
|
|
|
|
zap.String("requestID", requestID),
|
|
|
|
)
|
2023-01-26 06:54:41 -08:00
|
|
|
return nil, response.NewInvalidParamError(c, "MALFORMED TX HASH", errors.WithStack(err))
|
|
|
|
}
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2023-01-26 06:54:41 -08:00
|
|
|
return &txHashAddr, nil
|
|
|
|
}
|
2023-01-27 08:47:17 -08:00
|
|
|
|
|
|
|
// ExtractParsedPayload get parsedPayload query parameter.
|
|
|
|
func ExtractParsedPayload(c *fiber.Ctx, l *zap.Logger) (bool, error) {
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2023-01-27 08:47:17 -08:00
|
|
|
parsedPayloadStr := c.Query("parsedPayload", "false")
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2023-01-27 08:47:17 -08:00
|
|
|
parsedPayload, err := strconv.ParseBool(parsedPayloadStr)
|
|
|
|
if err != nil {
|
|
|
|
return false, response.NewInvalidQueryParamError(c, "INVALID <parsedPayload> QUERY PARAMETER", errors.WithStack(err))
|
|
|
|
}
|
2023-02-09 09:28:39 -08:00
|
|
|
|
2023-01-27 08:47:17 -08:00
|
|
|
return parsedPayload, nil
|
|
|
|
}
|
2023-02-01 04:59:51 -08:00
|
|
|
|
|
|
|
func ExtractAppId(c *fiber.Ctx, l *zap.Logger) string {
|
|
|
|
return c.Query("appId")
|
|
|
|
}
|
2023-03-07 11:25:42 -08:00
|
|
|
|
|
|
|
func ExtractTimeSpan(c *fiber.Ctx, l *zap.Logger) (string, error) {
|
|
|
|
// get the timeSpan from query params
|
|
|
|
timeSpanStr := c.Query("timeSpan", "1h")
|
|
|
|
if timeSpanStr == "all" {
|
|
|
|
return timeSpanStr, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// validate the timeSpan
|
|
|
|
if !isValidTimeSpan(timeSpanStr) {
|
|
|
|
return "", response.NewInvalidQueryParamError(c, "INVALID <timeSpan> QUERY PARAMETER", nil)
|
|
|
|
}
|
|
|
|
return timeSpanStr, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// isValidTimeSpan check if the timeSpan is valid
|
|
|
|
func isValidTimeSpan(timeSpan string) bool {
|
|
|
|
return regexp.MustCompile(`^all$|^\d+[mhdwy]$|^\dmo$`).MatchString(timeSpan)
|
|
|
|
}
|
|
|
|
|
|
|
|
func ExtractSampleRate(c *fiber.Ctx, l *zap.Logger) (string, error) {
|
|
|
|
// get the sampleRate from query params
|
|
|
|
sampleRateStr := c.Query("sampleRate", "1m")
|
|
|
|
if sampleRateStr == "1y" {
|
|
|
|
return sampleRateStr, nil
|
|
|
|
}
|
|
|
|
// validate the sampleRate
|
|
|
|
if !isValidSampleRate(sampleRateStr) {
|
|
|
|
return "", response.NewInvalidQueryParamError(c, "INVALID <sampleRate> QUERY PARAMETER", nil)
|
|
|
|
}
|
|
|
|
return sampleRateStr, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func isValidSampleRate(sampleRate string) bool {
|
|
|
|
return regexp.MustCompile(`^\d+[smhdwy]$|^\dmo$`).MatchString(sampleRate)
|
|
|
|
}
|
|
|
|
|
|
|
|
func ExtractTime(c *fiber.Ctx, queryParam string) (*time.Time, error) {
|
|
|
|
// get the start_time from query params
|
|
|
|
date := c.Query(queryParam, "")
|
|
|
|
if date == "" {
|
|
|
|
return nil, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
t, err := time.Parse("20060102T150405Z", date)
|
|
|
|
if err != nil {
|
|
|
|
return nil, response.NewInvalidQueryParamError(c, fmt.Sprintf("INVALID <%s> QUERY PARAMETER", queryParam), nil)
|
|
|
|
}
|
|
|
|
return &t, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func ExtractApps(ctx *fiber.Ctx) ([]string, error) {
|
|
|
|
apps := ctx.Query("apps")
|
|
|
|
if apps == "" {
|
|
|
|
return nil, nil
|
|
|
|
}
|
|
|
|
return strings.Split(apps, ","), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func ExtractIsNotional(ctx *fiber.Ctx) (bool, error) {
|
|
|
|
by := ctx.Query("by")
|
|
|
|
if by == "" {
|
|
|
|
return true, nil
|
|
|
|
}
|
|
|
|
if by == "notional" {
|
|
|
|
return true, nil
|
|
|
|
}
|
|
|
|
if by == "tx" {
|
|
|
|
return false, nil
|
|
|
|
}
|
|
|
|
return false, response.NewInvalidQueryParamError(ctx, "INVALID <by> QUERY PARAMETER", nil)
|
|
|
|
}
|