Interact: simple validation input

cmd/api/handlers/error.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"net/http"
 
+	"github.com/baking-bad/bcdhub/internal/bcd/ast"
 	"github.com/baking-bad/bcdhub/internal/logger"
 	"github.com/baking-bad/bcdhub/internal/models"
 	sentrygin "github.com/getsentry/sentry-go/gin"
@@ -39,6 +40,9 @@ func getErrorCode(err error, repo models.GeneralRepository) int {
 	if repo.IsRecordNotFound(err) {
 		return http.StatusNotFound
 	}
+	if errors.Is(err, ast.ErrValidation) {
+		return http.StatusBadRequest
+	}
 	return http.StatusInternalServerError
 }
 

internal/bcd/ast/address.go

@@ -115,8 +115,7 @@ func (a *Address) Distinguish(x Distinguishable) (*MiguelNode, error) {
 
 // FromJSONSchema -
 func (a *Address) FromJSONSchema(data map[string]interface{}) error {
-	setOptimizedJSONSchema(&a.Default, data, forge.UnforgeContract)
-	return nil
+	return setOptimizedJSONSchema(&a.Default, data, forge.UnforgeContract, AddressValidator)
 }
 
 // FindByName -

internal/bcd/ast/baker_hash.go

@@ -82,8 +82,7 @@ func (s *BakerHash) Distinguish(x Distinguishable) (*MiguelNode, error) {
 
 // FromJSONSchema -
 func (s *BakerHash) FromJSONSchema(data map[string]interface{}) error {
-	setOptimizedJSONSchema(&s.Default, data, forge.UnforgeBakerHash)
-	return nil
+	return setOptimizedJSONSchema(&s.Default, data, forge.UnforgeBakerHash, BakerHashValidator)
 }
 
 // FindByName -

internal/bcd/ast/chain_id.go

@@ -89,8 +89,7 @@ func (c *ChainID) Distinguish(x Distinguishable) (*MiguelNode, error) {
 
 // FromJSONSchema -
 func (c *ChainID) FromJSONSchema(data map[string]interface{}) error {
-	setOptimizedJSONSchema(&c.Default, data, forge.UnforgeChainID)
-	return nil
+	return setOptimizedJSONSchema(&c.Default, data, forge.UnforgeChainID, ChainIDValidator)
 }
 
 // FindByName -

internal/bcd/ast/default.go

@@ -194,12 +194,11 @@ func (d *Default) ToJSONSchema() (*JSONSchema, error) {
 
 // FromJSONSchema -
 func (d *Default) FromJSONSchema(data map[string]interface{}) error {
-	for key := range data {
-		if key == d.GetName() {
-			d.Value = data[key]
-			d.ValueKind = valueKindString
-			break
-		}
+	key := d.GetName()
+
+	if value, ok := data[key]; ok {
+		d.Value = value
+		d.ValueKind = valueKindString
 	}
 	return nil
 }

internal/bcd/ast/jsonschema.go

@@ -40,6 +40,9 @@ type JSONSchema struct {
 	XOptions   map[string]interface{} `json:"x-options,omitempty"`
 }
 
+// Optimizer -
+type Optimizer func(string) (string, error)
+
 func getStringJSONSchema(d Default) *JSONSchema {
 	return wrapObject(&JSONSchema{
 		Prim:    d.Prim,
@@ -70,49 +73,57 @@ func getAddressJSONSchema(d Default) *JSONSchema {
 }
 
 func setIntJSONSchema(d *Default, data map[string]interface{}) {
-	for key := range data {
-		if key == d.GetName() {
-			switch v := data[key].(type) {
-			case float64:
-				i := big.NewInt(0)
-				i, _ = big.NewFloat(v).Int(i)
-				d.Value = &types.BigInt{Int: i}
-			case string:
-				d.Value = types.NewBigIntFromString(v)
-			}
-			d.ValueKind = valueKindInt
-			break
+	key := d.GetName()
+	if value, ok := data[key]; ok {
+		switch v := value.(type) {
+		case float64:
+			i := big.NewInt(0)
+			i, _ = big.NewFloat(v).Int(i)
+			d.Value = &types.BigInt{Int: i}
+		case string:
+			d.Value = types.NewBigIntFromString(v)
 		}
+		d.ValueKind = valueKindInt
 	}
 }
 
 func setBytesJSONSchema(d *Default, data map[string]interface{}) error {
-	for key := range data {
-		if key == d.GetName() {
-			if _, err := hex.DecodeString(data[key].(string)); err != nil {
-				return errors.Errorf("invalid bytes string: %s=%v", key, data[key])
+	key := d.GetName()
+	if value, ok := data[key]; ok {
+		if str, ok := value.(string); ok {
+			if err := BytesValidator(str); err != nil {
+				return err
+			}
+			if _, err := hex.DecodeString(str); err != nil {
+				return errors.Errorf("bytes decoding error: %s=%v", key, value)
 			}
 
-			d.Value = data[key]
+			d.Value = value
 			d.ValueKind = valueKindBytes
-			return nil
 		}
 	}
 	return nil
 }
 
-func setOptimizedJSONSchema(d *Default, data map[string]interface{}, optimizer func(string) (string, error)) {
-	for key, value := range data {
-		if key == d.GetName() {
-			val, err := optimizer(value.(string))
+func setOptimizedJSONSchema(d *Default, data map[string]interface{}, optimizer Optimizer, validator Validator[string]) error {
+	key := d.GetName()
+	if value, ok := data[key]; ok {
+		if str, ok := value.(string); ok {
+			if validator != nil {
+				if err := validator(str); err != nil {
+					return err
+				}
+			}
+
+			val, err := optimizer(str)
 			if err != nil {
-				val = value.(string)
+				val = str
 			}
 			d.ValueKind = valueKindString
 			d.Value = val
-			break
 		}
 	}
+	return nil
 }
 
 type mergeFields struct {

internal/bcd/ast/key.go

@@ -83,8 +83,7 @@ func (k *Key) Distinguish(x Distinguishable) (*MiguelNode, error) {
 
 // FromJSONSchema -
 func (k *Key) FromJSONSchema(data map[string]interface{}) error {
-	setOptimizedJSONSchema(&k.Default, data, forge.UnforgePublicKey)
-	return nil
+	return setOptimizedJSONSchema(&k.Default, data, forge.UnforgePublicKey, PublicKeyValidator)
 }
 
 // FindByName -

internal/bcd/ast/key_hash.go

@@ -83,8 +83,7 @@ func (k *KeyHash) Distinguish(x Distinguishable) (*MiguelNode, error) {
 
 // FromJSONSchema -
 func (k *KeyHash) FromJSONSchema(data map[string]interface{}) error {
-	setOptimizedJSONSchema(&k.Default, data, forge.UnforgeAddress)
-	return nil
+	return setOptimizedJSONSchema(&k.Default, data, forge.UnforgeAddress, nil)
 }
 
 // FindByName -

internal/bcd/ast/signature.go

@@ -82,8 +82,7 @@ func (s *Signature) Distinguish(x Distinguishable) (*MiguelNode, error) {
 
 // FromJSONSchema -
 func (s *Signature) FromJSONSchema(data map[string]interface{}) error {
-	setOptimizedJSONSchema(&s.Default, data, forge.UnforgeSignature)
-	return nil
+	return setOptimizedJSONSchema(&s.Default, data, forge.UnforgeSignature, SignatureValidator)
 }
 
 // FindByName -

internal/bcd/ast/timestamp.go

@@ -77,21 +77,20 @@ func (t *Timestamp) ToBaseNode(optimized bool) (*base.Node, error) {
 
 // FromJSONSchema -
 func (t *Timestamp) FromJSONSchema(data map[string]interface{}) error {
-	for key := range data {
-		if key == t.GetName() {
-			t.ValueKind = valueKindInt
-			switch val := data[key].(type) {
-			case string:
-				ts, err := time.Parse(time.RFC3339, val)
-				if err != nil {
-					return err
-				}
-				t.Value = types.NewBigInt(ts.UTC().Unix())
-			case float64:
-				t.Value = types.NewBigInt(int64(val))
+	key := t.GetName()
+	if value, ok := data[key]; ok {
+		t.ValueKind = valueKindInt
+		switch val := value.(type) {
+		case string:
+			ts, err := time.Parse(time.RFC3339, val)
+			if err != nil {
+				return errors.Wrapf(ErrValidation, "time should be in RFC3339  %s=%s", key, val)
 			}
-			break
+			t.Value = types.NewBigInt(ts.UTC().Unix())
+		case float64:
+			t.Value = types.NewBigInt(int64(val))
 		}
+
 	}
 	return nil
 }

internal/bcd/ast/validators.go

@@ -0,0 +1,136 @@
+package ast
+
+import (
+	"regexp"
+	"strings"
+
+	"github.com/baking-bad/bcdhub/internal/bcd"
+	"github.com/baking-bad/bcdhub/internal/bcd/encoding"
+	"github.com/pkg/errors"
+)
+
+// errors
+var (
+	ErrValidation = errors.New("validation error")
+)
+
+// ValidatorConstraint -
+type ValidatorConstraint interface {
+	~string
+}
+
+// Validator -
+type Validator[T ValidatorConstraint] func(T) error
+
+var (
+	hexRegex = regexp.MustCompile("^[0-9a-fA-F]+$")
+)
+
+// AddressValidator -
+func AddressValidator(value string) error {
+	switch len(value) {
+	case 44, 42:
+		if !hexRegex.MatchString(value) {
+			return errors.Wrapf(ErrValidation, "address '%s' should be hexademical without prefixes", value)
+		}
+	case 36:
+		if !bcd.IsAddressLazy(value) {
+			return errors.Wrapf(ErrValidation, "invalid address '%s'", value)
+		}
+		if !bcd.IsAddress(value) {
+			return errors.Wrapf(ErrValidation, "invalid address '%s'", value)
+		}
+	default:
+		return errors.Wrap(ErrValidation, "invalid address length")
+	}
+
+	return nil
+}
+
+// BakerHashValidator -
+func BakerHashValidator(value string) error {
+	switch len(value) {
+	case 40:
+		if !hexRegex.MatchString(value) {
+			return errors.Wrapf(ErrValidation, "baker hash '%s' should be hexademical without prefixes", value)
+		}
+	case 36:
+		if !bcd.IsBakerHash(value) {
+			return errors.Wrapf(ErrValidation, "invalid baker hash '%s'", value)
+		}
+	default:
+		return errors.Wrap(ErrValidation, "invalid baker hash length")
+	}
+
+	return nil
+}
+
+// PublicKeyValidator -
+func PublicKeyValidator(value string) error {
+	switch len(value) {
+	case 68, 66:
+		if !hexRegex.MatchString(value) {
+			return errors.Wrapf(ErrValidation, "public key '%s' should be hexademical without prefixes", value)
+		}
+	case 55, 54:
+		if strings.HasPrefix(value, encoding.PrefixED25519PublicKey) ||
+			strings.HasPrefix(value, encoding.PrefixP256PublicKey) ||
+			strings.HasPrefix(value, encoding.PrefixSecp256k1PublicKey) {
+			return nil
+		}
+		return errors.Wrapf(ErrValidation, "invalid public key '%s'", value)
+	default:
+		return errors.Wrap(ErrValidation, "invalid public key length")
+	}
+
+	return nil
+}
+
+// BytesValidator -
+func BytesValidator(value string) error {
+	if len(value)%2 > 0 {
+		return errors.Wrapf(ErrValidation, "invalid bytes in hex length '%s'", value)
+	}
+	if !hexRegex.MatchString(value) {
+		return errors.Wrapf(ErrValidation, "bytes '%s' should be hexademical without prefixes", value)
+	}
+	return nil
+}
+
+// ChainIDValidator -
+func ChainIDValidator(value string) error {
+	switch len(value) {
+	case 8:
+		if !hexRegex.MatchString(value) {
+			return errors.Wrapf(ErrValidation, "chain id '%s' should be hexademical without prefixes", value)
+		}
+	case 15:
+		if strings.HasPrefix(value, encoding.PrefixChainID) {
+			return nil
+		}
+		return errors.Wrapf(ErrValidation, "invalid chain id '%s'", value)
+	default:
+		return errors.Wrap(ErrValidation, "invalid chain id length")
+	}
+
+	return nil
+}
+
+// SignatureValidator -
+func SignatureValidator(value string) error {
+	switch len(value) {
+	case 128:
+		if !hexRegex.MatchString(value) {
+			return errors.Wrapf(ErrValidation, "signature '%s' should be hexademical without prefixes", value)
+		}
+	case 96:
+		if strings.HasPrefix(value, encoding.PrefixGenericSignature) {
+			return nil
+		}
+		return errors.Wrapf(ErrValidation, "invalid signature '%s'", value)
+	default:
+		return errors.Wrap(ErrValidation, "invalid signature length")
+	}
+
+	return nil
+}