fix(api): restore safe validator listing

Author: onmax

server/utils/types.ts

@@ -25,7 +25,7 @@ export interface SnapshotEpochValidators {
 type Nullable<T> = {
   [K in keyof T]: T[K] | null
 }
-export type FetchedValidator = Omit<Validator, 'logo' | 'contact' | 'isListed'> & Pick<Activity, 'balance' | 'stakers'> & {
+export type FetchedValidator = Omit<Validator, 'logo' | 'contact'> & Pick<Activity, 'balance' | 'stakers'> & {
   logo?: string
   score: Nullable<Pick<Score, 'total' | 'availability' | 'reliability' | 'dominance' | 'epochNumber'>>
   dominanceRatio: number | null

server/utils/validator-listing.ts

@@ -1,5 +1,8 @@
+const UNKNOWN_VALIDATOR_NAME = 'Unknown validator'
+
 interface ValidatorListState {
   isListed: boolean | null
+  name: string
 }
 
 interface ValidatorAddress {
@@ -10,8 +13,10 @@ interface StoredValidatorAddressState extends ValidatorAddress {
   isListed: boolean | null
 }
 
-export function isKnownValidatorProfile({ isListed }: ValidatorListState) {
-  return isListed === true
+export function isKnownValidatorProfile({ isListed, name }: ValidatorListState) {
+  if (typeof isListed === 'boolean')
+    return isListed
+  return name.toLowerCase() !== UNKNOWN_VALIDATOR_NAME.toLowerCase()
 }
 
 export function getUnlistedAddresses(storedAddresses: string[], bundledAddresses: Set<string>) {

server/utils/validator-public.ts

@@ -1,8 +1,8 @@
 import type { Result } from 'nimiq-validator-trustscore/types'
 import type { ValidatorJSON } from './schemas'
+import { bundledValidatorsByNetwork } from '../generated/validators-bundle.generated'
 import { validatorSchema } from './schemas'
 import { getUnlistedAddresses } from './validator-listing'
-import { getStoredValidatorsAddress, markValidatorsAsUnlisted, storeValidator } from './validators'
 
 interface ImportValidatorsBundledOptions {
   shouldStore?: boolean
@@ -13,27 +13,22 @@ export async function importValidatorsBundled(nimiqNetwork?: string, options: Im
     return [false, 'Nimiq network is required', undefined]
 
   const { shouldStore = true } = options
-  const storage = useStorage('assets:public')
-  const keys = await storage.getKeys(`validators/${nimiqNetwork}`)
+  const bundledValidators = bundledValidatorsByNetwork[nimiqNetwork as keyof typeof bundledValidatorsByNetwork]
+  if (!bundledValidators || bundledValidators.length === 0)
+    return [false, `No bundled validators found for network: ${nimiqNetwork}`, undefined]
 
   const validators: ValidatorJSON[] = []
-  for (const key of keys) {
-    if (!key.endsWith('.json') || key.endsWith('.example.json'))
-      continue
-
-    const data = await storage.getItem(key)
+  for (const data of bundledValidators) {
     const parsed = validatorSchema.safeParse(data)
     if (!parsed.success)
-      return [false, `Invalid validator data at ${key}: ${parsed.error}`, undefined]
+      return [false, `Invalid bundled validator data: ${parsed.error}`, undefined]
     validators.push(parsed.data)
   }
 
   if (!shouldStore)
     return [true, undefined, validators]
 
-  if (validators.length === 0)
-    return [false, `No bundled validators found for network: ${nimiqNetwork}`, undefined]
-
+  const { getStoredValidatorsAddress, markValidatorsAsUnlisted, storeValidator } = await import('./validators')
   const bundledAddresses = new Set(validators.map(v => v.address))
   const storedAddresses = await getStoredValidatorsAddress()
   const unlistedAddresses = getUnlistedAddresses(storedAddresses, bundledAddresses)

server/utils/validators-bundle.ts

@@ -11,7 +11,6 @@ import { tables, useDrizzle } from './drizzle'
 import { handleValidatorLogo } from './logo'
 import { defaultValidatorJSON } from './schemas'
 import { getUnlistedActiveValidatorAddresses, isKnownValidatorProfile } from './validator-listing'
-import { stripInternalValidatorFields } from './validator-public'
 
 export const getStoredValidatorsId = () => useDrizzle().select({ id: tables.validators.id }).from(tables.validators).execute().then(r => r.map(v => v.id))
 export const getStoredValidatorsAddress = () => useDrizzle().select({ address: tables.validators.address }).from(tables.validators).execute().then(r => r.map(v => v.address))
@@ -39,6 +38,13 @@ async function selectValidatorsWithListState(filters: SQLWrapper[] = []) {
     : await query.execute()
 }
 
+export function filterVisibleValidators<T extends { isListed: boolean | null, name: string }>(validators: T[], onlyKnown: boolean): T[] {
+  if (!onlyKnown)
+    return validators
+
+  return validators.filter(isKnownValidatorProfile)
+}
+
 export async function getStoredValidatorsListState() {
   return useDrizzle()
     .select({ address: tables.validators.address, isListed: tables.validators.isListed })
@@ -137,7 +143,7 @@ export async function markValidatorsAsUnlisted(addresses: string[]) {
 export type FetchValidatorsOptions = MainQuerySchema & { epochNumber: number }
 
 export async function fetchValidators(_event: H3Event, params: FetchValidatorsOptions): Result<FetchedValidator[]> {
-  const { 'payout-type': payoutType, 'only-known': onlyKnown = false, 'with-identicons': withIdenticons, epochNumber } = params
+  const { 'payout-type': payoutType, 'only-known': onlyKnown = true, 'with-identicons': withIdenticons, epochNumber } = params
 
   // Add safety check for epochNumber
   if (epochNumber === null || epochNumber === undefined || !Number.isInteger(epochNumber)) {
@@ -152,7 +158,7 @@ export async function fetchValidators(_event: H3Event, params: FetchValidatorsOp
   try {
     const dbValidators = await selectValidatorsWithListState(filters)
 
-    const visibleValidators = onlyKnown ? dbValidators.filter(isKnownValidatorProfile) : dbValidators
+    const visibleValidators = filterVisibleValidators(dbValidators, onlyKnown)
     const validatorIds = visibleValidators.map(v => v.id)
     if (validatorIds.length === 0)
       return [true, undefined, []]
@@ -219,8 +225,7 @@ export async function fetchValidators(_event: H3Event, params: FetchValidatorsOp
     const activityByValidatorId = new Map(activityRows.map(row => [row.validatorId, row]))
 
     const validators = visibleValidators.map((validator) => {
-      const { logo, hasDefaultLogo } = validator
-      const rest = stripInternalValidatorFields(validator)
+      const { logo, hasDefaultLogo, contact: _contact, isListed, ...rest } = validator
       const scoreRow = scoresByValidatorId.get(validator.id)
       const activityRow = activityByValidatorId.get(validator.id)
 
@@ -243,6 +248,7 @@ export async function fetchValidators(_event: H3Event, params: FetchValidatorsOp
 
       return {
         ...rest,
+        isListed,
         score,
         hasDefaultLogo,
         logo: withIdenticons === false && hasDefaultLogo ? undefined : logo,
@@ -278,7 +284,7 @@ export const cachedFetchValidators = defineCachedFunction((_event: H3Event, para
 })
 
 export interface FetchValidatorOptions { address: string, range: Range }
-export type FetchedValidatorDetails = Omit<Validator, 'isListed'> & { activity: Activity[], scores: Score[], score?: Score }
+export type FetchedValidatorDetails = Validator & { activity: Activity[], scores: Score[], score?: Score }
 
 export async function fetchValidator(_event: H3Event, params: FetchValidatorOptions): Result<FetchedValidatorDetails> {
   const { address, range: { fromEpoch, toEpoch } } = params
@@ -321,8 +327,7 @@ export async function fetchValidator(_event: H3Event, params: FetchValidatorOpti
       ))
       .execute()
 
-    const publicValidator = stripInternalValidatorFields(validator)
-    return [true, undefined, { ...publicValidator, scores, activity, score }]
+    return [true, undefined, { ...validator, scores, activity, score }]
   }
   catch (error) {
     consola.error(`Error fetching validator ${address}: ${error}`)