Method validateProviderPrerequisites

x/verification/keeper/msg.go:1279–1320

(ctx sdk.Context, provider sdk.AccAddress, tier vtypes.VerificationTier)

}

func (k *keeper) validateProviderPrerequisites(ctx sdk.Context, provider sdk.AccAddress, tier vtypes.VerificationTier) error {
	if !vtypes.TierRequiresSnapshot(tier) {
		return nil
	}

	params := k.GetParams(ctx)
	if err := k.validateProviderAge(ctx, provider, tier, params); err != nil {
		return err
	}
	if err := k.validateProviderLeaseCompletion(ctx, provider, tier, params); err != nil {
		return err
	}

	snapshot, found := k.GetProviderSnapshot(ctx, provider)
	if !found {
		return moduletypes.ErrSnapshotNonCompliant
	}
	if snapshot.Suspended || snapshot.ComplianceDeadline.Before(ctx.BlockTime()) {
		return moduletypes.ErrProviderSnapshotSuspended
	}

	var bond vtypes.ProviderBondRecord
	if vtypes.TierRequiresProviderBond(tier) {
		var found bool
		bond, found = k.GetProviderBond(ctx, provider)
		if !found {
			return moduletypes.ErrInsufficientProviderBond
		}
		required := requiredProviderBond(params, tier, snapshot.ResourceSummary)
		if err := requireCoinAtLeast(bond.BondedAmount, required, moduletypes.ErrInsufficientProviderBond); err != nil {
			return err
		}
	}
	if err := k.validateProviderSlashingHistory(ctx, tier, params, bond); err != nil {
		return err
	}
	if vtypes.TierAtLeast(tier, vtypes.TierTrusted) && !k.hasContinuousL3History(ctx, provider, params.MinL3DurationForL4) {
		return moduletypes.ErrInsufficientL3History
	}

	return nil
}

func (k *keeper) validateProviderLeaseCompletion(ctx sdk.Context, provider sdk.AccAddress, tier vtypes.VerificationTier, params vtypes.Params) error {
	if k.market == nil || !vtypes.TierAtLeast(tier, vtypes.TierEstablished) {