@atproto/bsky 0.0.141 → 0.0.143

package/src/data-plane/server/indexing/plugins/verification.ts

@@ -0,0 +1,96 @@
+import { Selectable } from 'kysely'
+import { CID } from 'multiformats/cid'
+import { AtUri, normalizeDatetimeAlways } from '@atproto/syntax'
+import * as lex from '../../../../lexicon/lexicons'
+import * as Verification from '../../../../lexicon/types/app/bsky/graph/verification'
+import { BackgroundQueue } from '../../background'
+import { Database } from '../../db'
+import { DatabaseSchema, DatabaseSchemaType } from '../../db/database-schema'
+import { RecordProcessor } from '../processor'
+
+const lexId = lex.ids.AppBskyGraphVerification
+type IndexedVerification = Selectable<DatabaseSchemaType['verification']>
+
+const insertFn = async (
+  db: DatabaseSchema,
+  uri: AtUri,
+  cid: CID,
+  obj: Verification.Record,
+  timestamp: string,
+): Promise<IndexedVerification | null> => {
+  const inserted = await db
+    .insertInto('verification')
+    .values({
+      uri: uri.toString(),
+      cid: cid.toString(),
+      rkey: uri.rkey,
+      creator: uri.host,
+      subject: obj.subject,
+      handle: obj.handle,
+      displayName: obj.displayName,
+      createdAt: normalizeDatetimeAlways(obj.createdAt),
+      indexedAt: timestamp,
+    })
+    .onConflict((oc) => oc.doNothing())
+    .returningAll()
+    .executeTakeFirst()
+  return inserted || null
+}
+
+const findDuplicate = async (
+  db: DatabaseSchema,
+  uri: AtUri,
+  obj: Verification.Record,
+): Promise<AtUri | null> => {
+  const found = await db
+    .selectFrom('verification')
+    .where('subject', '=', obj.subject)
+    .where('creator', '=', uri.host)
+    .selectAll()
+    .executeTakeFirst()
+  return found ? new AtUri(found.uri) : null
+}
+
+const notifsForInsert = (_obj: IndexedVerification) => {
+  return []
+}
+
+const deleteFn = async (
+  db: DatabaseSchema,
+  uri: AtUri,
+): Promise<IndexedVerification | null> => {
+  const deleted = await db
+    .deleteFrom('verification')
+    .where('uri', '=', uri.toString())
+    .returningAll()
+    .executeTakeFirst()
+  return deleted || null
+}
+
+const notifsForDelete = (
+  _deleted: IndexedVerification,
+  _replacedBy: IndexedVerification | null,
+) => {
+  return { notifs: [], toDelete: [] }
+}
+
+export type PluginType = RecordProcessor<
+  Verification.Record,
+  IndexedVerification
+>
+
+export const makePlugin = (
+  db: Database,
+  background: BackgroundQueue,
+): PluginType => {
+  return new RecordProcessor(db, background, {
+    lexId,
+    insertFn,
+    findDuplicate,
+    deleteFn,
+    notifsForInsert,
+    notifsForDelete,
+  })
+}
+
+export default makePlugin

package/src/data-plane/server/routes/profile.ts

@@ -1,11 +1,21 @@
+import { Timestamp } from '@bufbuild/protobuf'
 import { ServiceImpl } from '@connectrpc/connect'
-import { sql } from 'kysely'
+import { Selectable, sql } from 'kysely'
 import { keyBy } from '@atproto/common'
 import { parseRecordBytes } from '../../../hydration/util'
 import { Service } from '../../../proto/bsky_connect'
+import { VerificationMeta } from '../../../proto/bsky_pb'
 import { Database } from '../db'
+import { Verification } from '../db/tables/verification'
 import { getRecords } from './records'
 
+type VerifiedBy = {
+  [handle: string]: Pick<
+    VerificationMeta,
+    'rkey' | 'handle' | 'displayName' | 'sortedAt'
+  >
+}
+
 export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
   async getActors(req) {
     const { dids } = req
@@ -19,30 +29,62 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
       (did) => `at://${did}/chat.bsky.actor.declaration/self`,
     )
     const { ref } = db.db.dynamic
-    const [handlesRes, profiles, chatDeclarations] = await Promise.all([
-      db.db
-        .selectFrom('actor')
-        .leftJoin('actor_state', 'actor_state.did', 'actor.did')
-        .where('actor.did', 'in', dids)
-        .selectAll('actor')
-        .select('actor_state.priorityNotifs')
-        .select([
-          db.db
-            .selectFrom('labeler')
-            .whereRef('creator', '=', ref('actor.did'))
-            .select(sql<true>`${true}`.as('val'))
-            .as('isLabeler'),
-        ])
-        .execute(),
-      getRecords(db)({ uris: profileUris }),
-      getRecords(db)({ uris: chatDeclarationUris }),
-    ])
+    const [handlesRes, verificationsReceived, profiles, chatDeclarations] =
+      await Promise.all([
+        db.db
+          .selectFrom('actor')
+          .leftJoin('actor_state', 'actor_state.did', 'actor.did')
+          .where('actor.did', 'in', dids)
+          .selectAll('actor')
+          .select('actor_state.priorityNotifs')
+          .select([
+            db.db
+              .selectFrom('labeler')
+              .whereRef('creator', '=', ref('actor.did'))
+              .select(sql<true>`${true}`.as('val'))
+              .as('isLabeler'),
+          ])
+          .execute(),
+        db.db
+          .selectFrom('verification')
+          .selectAll('verification')
+          .innerJoin('actor', 'actor.did', 'verification.creator')
+          .where('verification.subject', 'in', dids)
+          .where('actor.trustedVerifier', '=', true)
+          .orderBy('sortedAt', 'asc')
+          .execute(),
+        getRecords(db)({ uris: profileUris }),
+        getRecords(db)({ uris: chatDeclarationUris }),
+      ])
+
+    const verificationsBySubjectDid = verificationsReceived.reduce(
+      (acc, cur) => {
+        const list = acc.get(cur.subject) ?? []
+        list.push(cur)
+        acc.set(cur.subject, list)
+        return acc
+      },
+      new Map<string, Selectable<Verification>[]>(),
+    )
+
     const byDid = keyBy(handlesRes, 'did')
     const actors = dids.map((did, i) => {
       const row = byDid.get(did)
       const chatDeclaration = parseRecordBytes(
         chatDeclarations.records[i].record,
       )
+
+      const verifications = verificationsBySubjectDid.get(did) ?? []
+      const verifiedBy: VerifiedBy = verifications.reduce((acc, cur) => {
+        acc[cur.creator] = {
+          rkey: cur.rkey,
+          handle: cur.handle,
+          displayName: cur.displayName,
+          sortedAt: Timestamp.fromDate(new Date(cur.sortedAt)),
+        }
+        return acc
+      }, {} as VerifiedBy)
+
       return {
         exists: !!row,
         handle: row?.handle ?? undefined,
@@ -58,6 +100,8 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
         upstreamStatus: row?.upstreamStatus ?? '',
         createdAt: profiles.records[i].createdAt, // @NOTE profile creation date not trusted in production
         priorityNotifications: row?.priorityNotifs ?? false,
+        trustedVerifier: row?.trustedVerifier ?? false,
+        verifiedBy,
       }
     })
     return { actors }

package/src/hydration/actor.ts

@@ -1,6 +1,8 @@
+import { mapDefined } from '@atproto/common'
 import { DataPlaneClient } from '../data-plane/client'
 import { Record as ProfileRecord } from '../lexicon/types/app/bsky/actor/profile'
 import { Record as ChatDeclarationRecord } from '../lexicon/types/chat/bsky/actor/declaration'
+import { VerificationMeta } from '../proto/bsky_pb'
 import {
   HydrationMap,
   RecordInfo,
@@ -23,8 +25,20 @@ export type Actor = {
   upstreamStatus?: string
   createdAt?: Date
   priorityNotifications: boolean
+  trustedVerifier?: boolean
+  verifications: VerificationHydrationState[]
 }
 
+export type VerificationHydrationState = {
+  issuer: string
+  uri: string
+  handle: string
+  displayName: string
+  createdAt: string
+}
+
+export type VerificationMetaRequired = Required<VerificationMeta>
+
 export type Actors = HydrationMap<Actor>
 
 export type ChatDeclaration = RecordInfo<ChatDeclarationRecord>
@@ -127,6 +141,28 @@ export class ActorHydrator {
         ? parseRecord<ProfileRecord>(actor.profile, includeTakedowns)
         : undefined
 
+      const verifications = mapDefined(
+        Object.entries(actor.verifiedBy),
+        ([actorDid, verificationMeta]) => {
+          if (
+            verificationMeta.displayName &&
+            verificationMeta.handle &&
+            verificationMeta.rkey &&
+            verificationMeta.sortedAt
+          ) {
+            return {
+              issuer: actorDid,
+              uri: `at://${actorDid}/app.bsky.graph.verification/${verificationMeta.rkey}`,
+              handle: verificationMeta.handle,
+              displayName: verificationMeta.displayName,
+              createdAt: verificationMeta.sortedAt.toDate().toISOString(),
+            }
+          }
+          // Filter out the verification meta that doesn't contain all info.
+          return undefined
+        },
+      )
+
       return acc.set(did, {
         did,
         handle: parseString(actor.handle),
@@ -141,6 +177,8 @@ export class ActorHydrator {
         upstreamStatus: actor.upstreamStatus || undefined,
         createdAt: actor.createdAt?.toDate(),
         priorityNotifications: actor.priorityNotifications,
+        trustedVerifier: actor.trustedVerifier,
+        verifications,
       })
     }, new HydrationMap<Actor>())
   }

package/src/hydration/label.ts

@@ -16,6 +16,7 @@ import {
 export type { Label } from '../lexicon/types/com/atproto/label/defs'
 
 export type SubjectLabels = {
+  isImpersonation: boolean
   isTakendown: boolean
   needsReview: boolean
   labels: HydrationMap<Label> // src + val -> label
@@ -84,12 +85,14 @@ export class LabelHydrator {
       let entry = acc.get(label.uri)
       if (!entry) {
         entry = {
+          isImpersonation: false,
           isTakendown: false,
           needsReview: false,
           labels: new HydrationMap(),
         }
         acc.set(label.uri, entry)
       }
+
       const isActionableNeedsReview =
         label.val === NEEDS_REVIEW_LABEL &&
         !label.neg &&
@@ -110,6 +113,14 @@ export class LabelHydrator {
       if (isActionableNeedsReview) {
         entry.needsReview = true
       }
+      if (
+        label.val === IMPERSONATION_LABEL &&
+        !label.neg &&
+        labelers.redact.has(label.src)
+      ) {
+        entry.isImpersonation = true
+      }
+
       return acc
     }, new Labels())
   }
@@ -160,5 +171,6 @@ const labelerDidToUri = (did: string): string => {
   return AtUri.make(did, ids.AppBskyLabelerService, 'self').toString()
 }
 
+const IMPERSONATION_LABEL = 'impersonation'
 const TAKEDOWN_LABELS = ['!takedown', '!suspend']
 const NEEDS_REVIEW_LABEL = 'needs-review'

package/src/lexicon/lexicons.ts

@@ -4564,6 +4564,10 @@ export const schemaDict = {
             type: 'string',
             format: 'datetime',
           },
+          verification: {
+            type: 'ref',
+            ref: 'lex:app.bsky.actor.defs#verificationState',
+          },
         },
       },
       profileView: {
@@ -4615,6 +4619,10 @@ export const schemaDict = {
               ref: 'lex:com.atproto.label.defs#label',
             },
           },
+          verification: {
+            type: 'ref',
+            ref: 'lex:app.bsky.actor.defs#verificationState',
+          },
         },
       },
       profileViewDetailed: {
@@ -4687,6 +4695,10 @@ export const schemaDict = {
             type: 'ref',
             ref: 'lex:com.atproto.repo.strongRef',
           },
+          verification: {
+            type: 'ref',
+            ref: 'lex:app.bsky.actor.defs#verificationState',
+          },
         },
       },
       profileAssociated: {
@@ -4776,6 +4788,60 @@ export const schemaDict = {
           },
         },
       },
+      verificationState: {
+        type: 'object',
+        description:
+          'Represents the verification information about the user this object is attached to.',
+        required: ['verifications', 'verifiedStatus', 'trustedVerifierStatus'],
+        properties: {
+          verifications: {
+            type: 'array',
+            description:
+              'All verifications issued by trusted verifiers on behalf of this user. Verifications by untrusted verifiers are not included.',
+            items: {
+              type: 'ref',
+              ref: 'lex:app.bsky.actor.defs#verificationView',
+            },
+          },
+          verifiedStatus: {
+            type: 'string',
+            description: "The user's status as a verified account.",
+            knownValues: ['valid', 'invalid', 'none'],
+          },
+          trustedVerifierStatus: {
+            type: 'string',
+            description: "The user's status as a trusted verifier.",
+            knownValues: ['valid', 'invalid', 'none'],
+          },
+        },
+      },
+      verificationView: {
+        type: 'object',
+        description: 'An individual verification for an associated subject.',
+        required: ['issuer', 'uri', 'isValid', 'createdAt'],
+        properties: {
+          issuer: {
+            type: 'string',
+            description: 'The user who issued this verification.',
+            format: 'did',
+          },
+          uri: {
+            type: 'string',
+            description: 'The AT-URI of the verification record.',
+            format: 'at-uri',
+          },
+          isValid: {
+            type: 'boolean',
+            description:
+              'True if the verification passes validation, otherwise false.',
+          },
+          createdAt: {
+            type: 'string',
+            description: 'Timestamp when the verification was created.',
+            format: 'datetime',
+          },
+        },
+      },
       preferences: {
         type: 'array',
         items: {
@@ -4794,6 +4860,7 @@ export const schemaDict = {
             'lex:app.bsky.actor.defs#bskyAppStatePref',
             'lex:app.bsky.actor.defs#labelersPref',
             'lex:app.bsky.actor.defs#postInteractionSettingsPref',
+            'lex:app.bsky.actor.defs#verificationPrefs',
           ],
         },
       },
@@ -5127,6 +5194,19 @@ export const schemaDict = {
           },
         },
       },
+      verificationPrefs: {
+        type: 'object',
+        description: 'Preferences for how verified accounts appear in the app.',
+        required: [],
+        properties: {
+          hideBadges: {
+            description:
+              'Hide the blue check badges for verified accounts and trusted verifiers.',
+            type: 'boolean',
+            default: false,
+          },
+        },
+      },
       postInteractionSettingsPref: {
         type: 'object',
         description:
@@ -11014,6 +11094,10 @@ export const schemaDict = {
             description:
               'Set to true when the actor cannot actively participate in converations',
           },
+          verification: {
+            type: 'ref',
+            ref: 'lex:app.bsky.actor.defs#verificationState',
+          },
         },
       },
     },

package/src/lexicon/types/app/bsky/actor/defs.ts

@@ -29,6 +29,7 @@ export interface ProfileViewBasic {
   viewer?: ViewerState
   labels?: ComAtprotoLabelDefs.Label[]
   createdAt?: string
+  verification?: VerificationState
 }
 
 const hashProfileViewBasic = 'profileViewBasic'
@@ -53,6 +54,7 @@ export interface ProfileView {
   createdAt?: string
   viewer?: ViewerState
   labels?: ComAtprotoLabelDefs.Label[]
+  verification?: VerificationState
 }
 
 const hashProfileView = 'profileView'
@@ -83,6 +85,7 @@ export interface ProfileViewDetailed {
   viewer?: ViewerState
   labels?: ComAtprotoLabelDefs.Label[]
   pinnedPost?: ComAtprotoRepoStrongRef.Main
+  verification?: VerificationState
 }
 
 const hashProfileViewDetailed = 'profileViewDetailed'
@@ -169,6 +172,50 @@ export function validateKnownFollowers<V>(v: V) {
   return validate<KnownFollowers & V>(v, id, hashKnownFollowers)
 }
 
+/** Represents the verification information about the user this object is attached to. */
+export interface VerificationState {
+  $type?: 'app.bsky.actor.defs#verificationState'
+  /** All verifications issued by trusted verifiers on behalf of this user. Verifications by untrusted verifiers are not included. */
+  verifications: VerificationView[]
+  /** The user's status as a verified account. */
+  verifiedStatus: 'valid' | 'invalid' | 'none' | (string & {})
+  /** The user's status as a trusted verifier. */
+  trustedVerifierStatus: 'valid' | 'invalid' | 'none' | (string & {})
+}
+
+const hashVerificationState = 'verificationState'
+
+export function isVerificationState<V>(v: V) {
+  return is$typed(v, id, hashVerificationState)
+}
+
+export function validateVerificationState<V>(v: V) {
+  return validate<VerificationState & V>(v, id, hashVerificationState)
+}
+
+/** An individual verification for an associated subject. */
+export interface VerificationView {
+  $type?: 'app.bsky.actor.defs#verificationView'
+  /** The user who issued this verification. */
+  issuer: string
+  /** The AT-URI of the verification record. */
+  uri: string
+  /** True if the verification passes validation, otherwise false. */
+  isValid: boolean
+  /** Timestamp when the verification was created. */
+  createdAt: string
+}
+
+const hashVerificationView = 'verificationView'
+
+export function isVerificationView<V>(v: V) {
+  return is$typed(v, id, hashVerificationView)
+}
+
+export function validateVerificationView<V>(v: V) {
+  return validate<VerificationView & V>(v, id, hashVerificationView)
+}
+
 export type Preferences = (
   | $Typed<AdultContentPref>
   | $Typed<ContentLabelPref>
@@ -183,6 +230,7 @@ export type Preferences = (
   | $Typed<BskyAppStatePref>
   | $Typed<LabelersPref>
   | $Typed<PostInteractionSettingsPref>
+  | $Typed<VerificationPrefs>
   | { $type: string }
 )[]
 
@@ -496,6 +544,23 @@ export function validateNux<V>(v: V) {
   return validate<Nux & V>(v, id, hashNux)
 }
 
+/** Preferences for how verified accounts appear in the app. */
+export interface VerificationPrefs {
+  $type?: 'app.bsky.actor.defs#verificationPrefs'
+  /** Hide the blue check badges for verified accounts and trusted verifiers. */
+  hideBadges: boolean
+}
+
+const hashVerificationPrefs = 'verificationPrefs'
+
+export function isVerificationPrefs<V>(v: V) {
+  return is$typed(v, id, hashVerificationPrefs)
+}
+
+export function validateVerificationPrefs<V>(v: V) {
+  return validate<VerificationPrefs & V>(v, id, hashVerificationPrefs)
+}
+
 /** Default post interaction settings for the account. These values should be applied as default values when creating new posts. These refs should mirror the threadgate and postgate records exactly. */
 export interface PostInteractionSettingsPref {
   $type?: 'app.bsky.actor.defs#postInteractionSettingsPref'

package/src/lexicon/types/chat/bsky/actor/defs.ts

@@ -27,6 +27,7 @@ export interface ProfileViewBasic {
   labels?: ComAtprotoLabelDefs.Label[]
   /** Set to true when the actor cannot actively participate in converations */
   chatDisabled?: boolean
+  verification?: AppBskyActorDefs.VerificationState
 }
 
 const hashProfileViewBasic = 'profileViewBasic'

package/src/proto/bsky_connect.ts

@@ -168,6 +168,12 @@ import {
   GetTimelineResponse,
   GetUnreadNotificationCountRequest,
   GetUnreadNotificationCountResponse,
+  GetVerificationRecordsRequest,
+  GetVerificationRecordsResponse,
+  GetVerificationsIssuedRequest,
+  GetVerificationsIssuedResponse,
+  GetVerificationsReceivedRequest,
+  GetVerificationsReceivedResponse,
   PingRequest,
   PingResponse,
   SearchActorsRequest,
@@ -373,6 +379,35 @@ export const Service = {
       O: GetFollowsResponse,
       kind: MethodKind.Unary,
     },
+    /**
+     * Verifications
+     *
+     * @generated from rpc bsky.Service.GetVerificationRecords
+     */
+    getVerificationRecords: {
+      name: 'GetVerificationRecords',
+      I: GetVerificationRecordsRequest,
+      O: GetVerificationRecordsResponse,
+      kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc bsky.Service.GetVerificationsIssued
+     */
+    getVerificationsIssued: {
+      name: 'GetVerificationsIssued',
+      I: GetVerificationsIssuedRequest,
+      O: GetVerificationsIssuedResponse,
+      kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc bsky.Service.GetVerificationsReceived
+     */
+    getVerificationsReceived: {
+      name: 'GetVerificationsReceived',
+      I: GetVerificationsReceivedRequest,
+      O: GetVerificationsReceivedResponse,
+      kind: MethodKind.Unary,
+    },
     /**
      * Likes
      *