115 lines
3.9 KiB
Go
115 lines
3.9 KiB
Go
// package middleare contains all the middleware function to use in the API.
|
|
package middleware
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
|
|
"github.com/certusone/wormhole/node/pkg/vaa"
|
|
"github.com/gofiber/fiber/v2"
|
|
"github.com/pkg/errors"
|
|
"github.com/wormhole-foundation/wormhole-explorer/api/response"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
// ExtractChainID get chain parameter from route path.
|
|
func ExtractChainID(c *fiber.Ctx, l *zap.Logger) (vaa.ChainID, error) {
|
|
chain, err := c.ParamsInt("chain")
|
|
if err != nil {
|
|
requestID := fmt.Sprintf("%v", c.Locals("requestid"))
|
|
l.Error("failed to get chain parameter", zap.Error(err), zap.Int("chain", chain),
|
|
zap.String("requestID", requestID))
|
|
|
|
return vaa.ChainIDUnset, response.NewInvalidParamError(c, "WRONG CHAIN ID", errors.WithStack(err))
|
|
}
|
|
return vaa.ChainID(chain), nil
|
|
}
|
|
|
|
// ExtractEmitterAddr get emitter parameter from route path.
|
|
func ExtractEmitterAddr(c *fiber.Ctx, l *zap.Logger) (*vaa.Address, error) {
|
|
emitterStr := c.Params("emitter")
|
|
emitter, err := vaa.StringToAddress(emitterStr)
|
|
if err != nil {
|
|
requestID := fmt.Sprintf("%v", c.Locals("requestid"))
|
|
l.Error("failed to covert emitter to address", zap.Error(err), zap.String("emitterStr", emitterStr),
|
|
zap.String("requestID", requestID))
|
|
return nil, response.NewInvalidParamError(c, "MALFORMED EMITTER_ADDR", errors.WithStack(err))
|
|
}
|
|
return &emitter, nil
|
|
}
|
|
|
|
// ExtractSequence get sequence parameter from route path.
|
|
func ExtractSequence(c *fiber.Ctx, l *zap.Logger) (uint64, error) {
|
|
sequence := c.Params("sequence")
|
|
seq, err := strconv.ParseUint(sequence, 10, 64)
|
|
if err != nil {
|
|
requestID := fmt.Sprintf("%v", c.Locals("requestid"))
|
|
l.Error("failed to get sequence parameter", zap.Error(err), zap.String("sequence", sequence),
|
|
zap.String("requestID", requestID))
|
|
return 0, response.NewInvalidParamError(c, "MALFORMED SEQUENCE NUMBER", errors.WithStack(err))
|
|
}
|
|
return seq, nil
|
|
}
|
|
|
|
// ExtractGuardianAddress get guardian address from route path.
|
|
func ExtractGuardianAddress(c *fiber.Ctx, l *zap.Logger) (string, error) {
|
|
//TODO: check guardianAddress [vaa.StringToAddress(emitterStr)]
|
|
guardianAddress := c.Params("guardian_address")
|
|
if guardianAddress == "" {
|
|
return "", response.NewInvalidParamError(c, "MALFORMED GUARDIAN ADDR", nil)
|
|
}
|
|
return guardianAddress, nil
|
|
}
|
|
|
|
// ExtractVAAParams get VAA chain, address from route path.
|
|
func ExtractVAAChainIDEmitter(c *fiber.Ctx, l *zap.Logger) (vaa.ChainID, *vaa.Address, error) {
|
|
chainID, err := ExtractChainID(c, l)
|
|
if err != nil {
|
|
return vaa.ChainIDUnset, nil, err
|
|
}
|
|
address, err := ExtractEmitterAddr(c, l)
|
|
if err != nil {
|
|
return chainID, nil, err
|
|
}
|
|
return chainID, address, nil
|
|
}
|
|
|
|
// ExtractVAAParams get VAAA chain, address and sequence from route path.
|
|
func ExtractVAAParams(c *fiber.Ctx, l *zap.Logger) (vaa.ChainID, *vaa.Address, uint64, error) {
|
|
chainID, err := ExtractChainID(c, l)
|
|
if err != nil {
|
|
return vaa.ChainIDUnset, nil, 0, err
|
|
}
|
|
address, err := ExtractEmitterAddr(c, l)
|
|
if err != nil {
|
|
return chainID, nil, 0, err
|
|
}
|
|
seq, err := ExtractSequence(c, l)
|
|
if err != nil {
|
|
return chainID, address, 0, err
|
|
}
|
|
return chainID, address, seq, nil
|
|
}
|
|
|
|
// ExtractObservationSigner get signer from route path.
|
|
func ExtractObservationSigner(c *fiber.Ctx, l *zap.Logger) (*vaa.Address, error) {
|
|
signer := c.Params("signer")
|
|
signerAddr, err := vaa.StringToAddress(signer)
|
|
if err != nil {
|
|
requestID := fmt.Sprintf("%v", c.Locals("requestid"))
|
|
l.Error("failed to covert signer to address", zap.Error(err), zap.String("signer", signer),
|
|
zap.String("requestID", requestID))
|
|
return nil, response.NewInvalidParamError(c, "MALFORMED SIGNER", errors.WithStack(err))
|
|
}
|
|
return &signerAddr, nil
|
|
}
|
|
|
|
// ExtractObservationHash get a hash from route path.
|
|
func ExtractObservationHash(c *fiber.Ctx, l *zap.Logger) (string, error) {
|
|
hash := c.Params("hash")
|
|
if hash == "" {
|
|
return "", response.NewInvalidParamError(c, "MALFORMED HASH", nil)
|
|
}
|
|
return hash, nil
|
|
}
|