scroll/coordinator/internal/logic/auth/login.go

package auth

import (
	"errors"
	"fmt"
	"strings"

	"github.com/gin-gonic/gin"
	"github.com/scroll-tech/go-ethereum/log"
	"gorm.io/gorm"

	"scroll-tech/common/version"

	"scroll-tech/coordinator/internal/config"
	"scroll-tech/coordinator/internal/logic/verifier"
	"scroll-tech/coordinator/internal/orm"
	"scroll-tech/coordinator/internal/types"
)

// LoginLogic the auth logic
type LoginLogic struct {
	cfg          *config.Config
	challengeOrm *orm.Challenge

	openVmVks map[string]struct{}

	proverVersionHardForkMap map[string][]string
}

// NewLoginLogic new a LoginLogic
func NewLoginLogic(db *gorm.DB, cfg *config.Config, vf *verifier.Verifier) *LoginLogic {
	proverVersionHardForkMap := make(map[string][]string)

	var hardForks []string
	for _, cfg := range cfg.ProverManager.Verifier.Verifiers {
		hardForks = append(hardForks, cfg.ForkName)
	}
	proverVersionHardForkMap[cfg.ProverManager.Verifier.MinProverVersion] = hardForks

	return &LoginLogic{
		cfg:                      cfg,
		openVmVks:                vf.OpenVMVkMap,
		challengeOrm:             orm.NewChallenge(db),
		proverVersionHardForkMap: proverVersionHardForkMap,
	}
}

// InsertChallengeString insert and check the challenge string is existed
func (l *LoginLogic) InsertChallengeString(ctx *gin.Context, challenge string) error {
	return l.challengeOrm.InsertChallenge(ctx.Copy(), challenge)
}

func (l *LoginLogic) Check(login *types.LoginParameter) error {
	verify, err := login.Verify()
	if err != nil || !verify {
		log.Error("auth message verify failure", "prover_name", login.Message.ProverName,
			"prover_version", login.Message.ProverVersion, "message", login.Message)
		return errors.New("auth message verify failure")
	}

	if !version.CheckScrollRepoVersion(login.Message.ProverVersion, l.cfg.ProverManager.Verifier.MinProverVersion) {
		return fmt.Errorf("incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s", l.cfg.ProverManager.Verifier.MinProverVersion, login.Message.ProverVersion)
	}

	vks := make(map[string]struct{})
	for vk := range l.openVmVks {
		vks[vk] = struct{}{}
	}

	for _, vk := range login.Message.VKs {
		if _, ok := vks[vk]; !ok {
			log.Error("vk inconsistency", "prover vk", vk, "prover name", login.Message.ProverName,
				"prover_version", login.Message.ProverVersion, "message", login.Message)
			if !version.CheckScrollProverVersion(login.Message.ProverVersion) {
				return fmt.Errorf("incompatible prover version. please upgrade your prover, expect version: %s, actual version: %s",
					version.Version, login.Message.ProverVersion)
			}
			// if the prover reports a same prover version
			return errors.New("incompatible vk. please check your params files or config files")
		}
	}

	if login.Message.ProverProviderType != types.ProverProviderTypeInternal && login.Message.ProverProviderType != types.ProverProviderTypeExternal {
		// for backward compatibility, set ProverProviderType as internal
		if login.Message.ProverProviderType == types.ProverProviderTypeUndefined {
			login.Message.ProverProviderType = types.ProverProviderTypeInternal
		} else {
			log.Error("invalid prover_provider_type", "value", login.Message.ProverProviderType, "prover name", login.Message.ProverName, "prover version", login.Message.ProverVersion)
			return errors.New("invalid prover provider type.")
		}
	}

	return nil
}

// ProverHardForkName retrieves hard fork name which prover belongs to
func (l *LoginLogic) ProverHardForkName(login *types.LoginParameter) (string, error) {
	proverVersionSplits := strings.Split(login.Message.ProverVersion, "-")
	if len(proverVersionSplits) == 0 {
		return "", fmt.Errorf("invalid prover prover_version:%s", login.Message.ProverVersion)
	}

	proverVersion := proverVersionSplits[0]
	if hardForkNames, ok := l.proverVersionHardForkMap[proverVersion]; ok {
		return strings.Join(hardForkNames, ","), nil
	}

	return "", fmt.Errorf("invalid prover prover_version:%s", login.Message.ProverVersion)
}