Fix whitespace

Author: Sneagan

server/tokens.go

@@ -76,24 +76,28 @@ func (c *Server) BlindedTokenIssuerHandlerV2(w http.ResponseWriter, r *http.Requ
 			)
 			return WrapError(err, "Could not parse the request body", 400)
 		}
+
 		if request.BlindedTokens == nil {
 			c.Logger.Debug("Empty request")
 			return &AppError{
 				Message: "Empty request",
 				Code:    http.StatusBadRequest,
 			}
 		}
+
 		if request.IssuerCohort != 0 && request.IssuerCohort != 1 {
 			c.Logger.Debug("Not supported Cohort")
 			return &AppError{
 				Message: "Not supported Cohort",
 				Code:    http.StatusBadRequest,
 			}
 		}
+
 		issuer, appErr := c.GetLatestIssuer(issuerType, request.IssuerCohort)
 		if appErr != nil {
 			return appErr
 		}
+
 		// get latest signing key from issuer
 		var signingKey *crypto.SigningKey
 		if len(issuer.Keys) > 0 {
@@ -110,6 +114,7 @@ func (c *Server) BlindedTokenIssuerHandlerV2(w http.ResponseWriter, r *http.Requ
 				Code:    http.StatusBadRequest,
 			}
 		}
+
 		signedTokens, proof, err := btd.ApproveTokens(request.BlindedTokens, signingKey)
 		if err != nil {
 			c.Logger.Debug("Could not approve new tokens")
@@ -141,18 +146,22 @@ func (c *Server) blindedTokenIssuerHandler(w http.ResponseWriter, r *http.Reques
 		if appErr != nil {
 			return appErr
 		}
+
 		var request blindedTokenIssueRequest
+
 		if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, maxRequestSize)).Decode(&request); err != nil {
 			c.Logger.Debug("Could not parse the request body")
 			return WrapError(err, "Could not parse the request body", 400)
 		}
+
 		if request.BlindedTokens == nil {
 			c.Logger.Debug("Empty request")
 			return &AppError{
 				Message: "Empty request",
 				Code:    http.StatusBadRequest,
 			}
 		}
+
 		// get latest signing key from issuer
 		var signingKey *crypto.SigningKey
 		if len(issuer.Keys) > 0 {
@@ -169,6 +178,7 @@ func (c *Server) blindedTokenIssuerHandler(w http.ResponseWriter, r *http.Reques
 				Code:    http.StatusBadRequest,
 			}
 		}
+
 		signedTokens, proof, err := btd.ApproveTokens(request.BlindedTokens, signingKey)
 		if err != nil {
 			c.Logger.Debug("Could not approve new tokens")
@@ -216,37 +226,44 @@ func (c *Server) blindedTokenRedeemHandlerV3(w http.ResponseWriter, r *http.Requ
 			}
 		default:
 			c.Logger.Error("error fetching issuer", slog.Any("error", err))
+
 			return &AppError{
 				Cause:   errors.New("internal server error"),
 				Message: "Internal server error could not retrieve issuer",
 				Code:    http.StatusInternalServerError,
 			}
 		}
 	}
+
 	if issuer.Version != 3 {
 		return &AppError{
 			Message: "Issuer must be version 3",
 			Code:    http.StatusBadRequest,
 		}
 	}
+
 	now := time.Now()
+
 	if issuer.HasExpired(now) {
 		return &AppError{
 			Message: "Issuer has expired",
 			Code:    http.StatusBadRequest,
 		}
 	}
+
 	var request blindedTokenRedeemRequest
 	if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, maxRequestSize)).Decode(&request); err != nil {
 		c.Logger.Debug("Could not parse the request body")
 		return WrapError(err, "Could not parse the request body", http.StatusBadRequest)
 	}
+
 	if request.isEmpty() {
 		return &AppError{
 			Message: "Empty request",
 			Code:    http.StatusBadRequest,
 		}
 	}
+
 	skeys, err := issuer.FindSigningKeys(now)
 	if err != nil {
 		switch {
@@ -255,31 +272,37 @@ func (c *Server) blindedTokenRedeemHandlerV3(w http.ResponseWriter, r *http.Requ
 				Message: "Issuer must be version 3",
 				Code:    http.StatusBadRequest,
 			}
+
 		case errors.Is(err, model.ErrInvalidIV3Key):
 			return &AppError{
 				Message: "Issuer has invalid keys for v3",
 				Code:    http.StatusBadRequest,
 			}
+
 		default:
 			return &AppError{
 				Message: "Something went wrong",
 				Code:    http.StatusBadRequest,
 			}
 		}
 	}
+
 	if len(skeys) == 0 {
 		c.Logger.Error("failed to find appropriate key", "at", now)
+
 		return &AppError{
 			Message: "Issuer has no key that corresponds to start < now < end",
 			Code:    http.StatusBadRequest,
 		}
 	}
+
 	if err := btd.VerifyTokenRedemption(request.TokenPreimage, request.Signature, request.Payload, skeys); err != nil {
 		return &AppError{
 			Message: "Could not verify that token redemption is valid",
 			Code:    http.StatusBadRequest,
 		}
 	}
+
 	if err := c.RedeemToken(issuer, request.TokenPreimage, request.Payload, 0); err != nil {
 		c.Logger.Error("error redeeming token")
 		if errors.Is(err, errDuplicateRedemption) {
@@ -294,6 +317,7 @@ func (c *Server) blindedTokenRedeemHandlerV3(w http.ResponseWriter, r *http.Requ
 			Code:    http.StatusInternalServerError,
 		}
 	}
+
 	result := blindedTokenRedeemResponse{issuer.IssuerCohort}
 
 	if err := RenderContent(result, w, http.StatusOK); err != nil {
@@ -314,28 +338,34 @@ func (c *Server) blindedTokenRedeemHandler(w http.ResponseWriter, r *http.Reques
 		if appErr != nil {
 			return appErr
 		}
+
 		var request blindedTokenRedeemRequest
+
 		if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, maxRequestSize)).Decode(&request); err != nil {
 			c.Logger.Debug("Could not parse the request body")
 			return WrapError(err, "Could not parse the request body", 400)
 		}
+
 		if request.TokenPreimage == nil || request.Signature == nil {
 			c.Logger.Error("Empty request")
 			return &AppError{
 				Message: "Empty request",
 				Code:    http.StatusBadRequest,
 			}
 		}
+
 		var (
 			verified       bool
 			verifiedIssuer = &model.Issuer{}
 			verifiedCohort = int16(0)
 			now            = time.Now()
 		)
+
 		for _, issuer := range issuers {
 			if issuer.HasExpired(now) {
 				continue
 			}
+
 			// get latest signing key from issuer
 			var signingKey *crypto.SigningKey
 			if len(issuer.Keys) > 0 {
@@ -352,6 +382,7 @@ func (c *Server) blindedTokenRedeemHandler(w http.ResponseWriter, r *http.Reques
 					Code:    http.StatusBadRequest,
 				}
 			}
+
 			if err := btd.VerifyTokenRedemption(request.TokenPreimage, request.Signature, request.Payload, []*crypto.SigningKey{signingKey}); err != nil {
 				verified = false
 			} else {
@@ -368,6 +399,7 @@ func (c *Server) blindedTokenRedeemHandler(w http.ResponseWriter, r *http.Reques
 				Code:    http.StatusBadRequest,
 			}
 		}
+
 		if err := c.RedeemToken(verifiedIssuer, request.TokenPreimage, request.Payload, 0); err != nil {
 			if errors.Is(err, errDuplicateRedemption) {
 				return &AppError{
@@ -397,31 +429,37 @@ func (c *Server) blindedTokenRedeemHandler(w http.ResponseWriter, r *http.Reques
 func (c *Server) blindedTokenBulkRedeemHandler(w http.ResponseWriter, r *http.Request) *AppError {
 	v1BlindedTokenCallTotal.WithLabelValues("bulkRedeemTokens").Inc()
 	var request BlindedTokenBulkRedeemRequest
+
 	if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, maxRequestSize)).Decode(&request); err != nil {
 		c.Logger.Debug("Could not parse the request body")
 		return WrapError(err, "Could not parse the request body", 400)
 	}
+
 	tx, err := c.db.Begin()
 	if err != nil {
 		c.Logger.Debug("Could not start bulk token redemption db transaction")
 		return WrapError(err, "Could not start bulk token redemption db transaction", 400)
 	}
+
 	for _, token := range request.Tokens {
 		// @TODO: this code seems to be from an old version - we use the `redeemTokenWithDB`, and we have no tests, so I
 		// assume that is no longer used, hence the usage of v1Cohort.
 		issuer, appErr := c.GetLatestIssuer(token.Issuer, v1Cohort)
+
 		if appErr != nil {
 			_ = tx.Rollback()
 			c.Logger.Error(appErr.Error())
 			return appErr
 		}
+
 		if token.TokenPreimage == nil || token.Signature == nil {
 			_ = tx.Rollback()
 			return &AppError{
 				Message: "Missing preimage or signature",
 				Code:    http.StatusBadRequest,
 			}
 		}
+
 		// get latest signing key from issuer
 		var signingKey *crypto.SigningKey
 		if len(issuer.Keys) > 0 {
@@ -438,12 +476,14 @@ func (c *Server) blindedTokenBulkRedeemHandler(w http.ResponseWriter, r *http.Re
 				Code:    http.StatusBadRequest,
 			}
 		}
+
 		err := btd.VerifyTokenRedemption(token.TokenPreimage, token.Signature, request.Payload, []*crypto.SigningKey{signingKey})
 		if err != nil {
 			c.Logger.Error(err.Error())
 			_ = tx.Rollback()
 			return WrapError(err, "Could not verify that token redemption is valid", 400)
 		}
+
 		if err := redeemTokenWithDB(tx, token.Issuer, token.TokenPreimage, request.Payload); err != nil {
 			c.Logger.Error(err.Error())
 			_ = tx.Rollback()
@@ -470,7 +510,7 @@ func (c *Server) blindedTokenBulkRedeemHandler(w http.ResponseWriter, r *http.Re
 		}
 	}
 
-	if err := RenderContent(map[string]interface{}{}, w, http.StatusOK); err != nil {
+	if err := RenderContent(map[string]any{}, w, http.StatusOK); err != nil {
 		return &AppError{
 			Cause:   err,
 			Message: "Error encoding response",
@@ -491,6 +531,7 @@ func (c *Server) blindedTokenRedemptionHandler(w http.ResponseWriter, r *http.Re
 				Code:    http.StatusBadRequest,
 			}
 		}
+
 		tokenID, err := url.PathUnescape(tokenID)
 		if err != nil {
 			c.Logger.Debug("Bad request - incorrect token ID")
@@ -499,6 +540,7 @@ func (c *Server) blindedTokenRedemptionHandler(w http.ResponseWriter, r *http.Re
 				Code:    http.StatusBadRequest,
 			}
 		}
+
 		issuer, err := c.fetchIssuer(issuerID)
 		if err != nil {
 			c.Logger.Debug("Bad request - incorrect issuer ID")
@@ -507,6 +549,7 @@ func (c *Server) blindedTokenRedemptionHandler(w http.ResponseWriter, r *http.Re
 				Code:    http.StatusBadRequest,
 			}
 		}
+
 		if issuer.Version == 2 {
 			redemption, err := c.fetchRedemptionV2(uuid.NewSHA1(*issuer.ID, []byte(tokenID)))
 			if err != nil {