@atproto/identity 0.2.1 → 0.3.1

package/dist/types.d.ts

@@ -1,4 +1,6 @@
-import * as z from 'zod';
+import { DidDocument } from '@atproto/common-web';
+export { didDocument } from '@atproto/common-web';
+export type { DidDocument } from '@atproto/common-web';
 export declare type IdentityResolverOpts = {
     timeout?: number;
     plcUrl?: string;
@@ -25,102 +27,12 @@ export declare type CacheResult = {
     doc: DidDocument;
     updatedAt: number;
     stale: boolean;
+    expired: boolean;
 };
 export interface DidCache {
-    cacheDid(did: string, doc: DidDocument): Promise<void>;
+    cacheDid(did: string, doc: DidDocument, prevResult?: CacheResult): Promise<void>;
     checkCache(did: string): Promise<CacheResult | null>;
-    refreshCache(did: string, getDoc: () => Promise<DidDocument | null>): Promise<void>;
+    refreshCache(did: string, getDoc: () => Promise<DidDocument | null>, prevResult?: CacheResult): Promise<void>;
     clearEntry(did: string): Promise<void>;
     clear(): Promise<void>;
 }
-export declare const verificationMethod: z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodString;
-    controller: z.ZodString;
-    publicKeyMultibase: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    type: string;
-    controller: string;
-    publicKeyMultibase?: string | undefined;
-}, {
-    id: string;
-    type: string;
-    controller: string;
-    publicKeyMultibase?: string | undefined;
-}>;
-export declare const service: z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodString;
-    serviceEndpoint: z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    type: string;
-    serviceEndpoint: (string | Record<string, unknown>) & (string | Record<string, unknown> | undefined);
-}, {
-    id: string;
-    type: string;
-    serviceEndpoint: (string | Record<string, unknown>) & (string | Record<string, unknown> | undefined);
-}>;
-export declare const didDocument: z.ZodObject<{
-    id: z.ZodString;
-    alsoKnownAs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    verificationMethod: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        type: z.ZodString;
-        controller: z.ZodString;
-        publicKeyMultibase: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        id: string;
-        type: string;
-        controller: string;
-        publicKeyMultibase?: string | undefined;
-    }, {
-        id: string;
-        type: string;
-        controller: string;
-        publicKeyMultibase?: string | undefined;
-    }>, "many">>;
-    service: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        type: z.ZodString;
-        serviceEndpoint: z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
-    }, "strip", z.ZodTypeAny, {
-        id: string;
-        type: string;
-        serviceEndpoint: (string | Record<string, unknown>) & (string | Record<string, unknown> | undefined);
-    }, {
-        id: string;
-        type: string;
-        serviceEndpoint: (string | Record<string, unknown>) & (string | Record<string, unknown> | undefined);
-    }>, "many">>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    alsoKnownAs?: string[] | undefined;
-    verificationMethod?: {
-        id: string;
-        type: string;
-        controller: string;
-        publicKeyMultibase?: string | undefined;
-    }[] | undefined;
-    service?: {
-        id: string;
-        type: string;
-        serviceEndpoint: (string | Record<string, unknown>) & (string | Record<string, unknown> | undefined);
-    }[] | undefined;
-}, {
-    id: string;
-    alsoKnownAs?: string[] | undefined;
-    verificationMethod?: {
-        id: string;
-        type: string;
-        controller: string;
-        publicKeyMultibase?: string | undefined;
-    }[] | undefined;
-    service?: {
-        id: string;
-        type: string;
-        serviceEndpoint: (string | Record<string, unknown>) & (string | Record<string, unknown> | undefined);
-    }[] | undefined;
-}>;
-export declare type DidDocument = z.infer<typeof didDocument>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/identity",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "license": "MIT",
   "description": "Library for decentralized identities in atproto using DIDs and handles",
   "keywords": [
@@ -17,9 +17,8 @@
   "main": "dist/index.js",
   "dependencies": {
     "axios": "^0.27.2",
-    "zod": "^3.21.4",
-    "@atproto/common-web": "^0.2.1",
-    "@atproto/crypto": "^0.2.2"
+    "@atproto/common-web": "^0.2.3",
+    "@atproto/crypto": "^0.2.3"
   },
   "devDependencies": {
     "@did-plc/lib": "^0.0.1",

package/src/did/atproto-data.ts

@@ -1,73 +1,39 @@
 import * as crypto from '@atproto/crypto'
 import { DidDocument, AtprotoData } from '../types'
+import {
+  getDid,
+  getHandle,
+  getPdsEndpoint,
+  getFeedGenEndpoint,
+  getNotifEndpoint,
+  getSigningKey,
+} from '@atproto/common-web'
 
-export const getDid = (doc: DidDocument): string => {
-  const id = doc.id
-  if (typeof id !== 'string') {
-    throw new Error('No `id` on document')
-  }
-  return id
+export {
+  getDid,
+  getHandle,
+  getPdsEndpoint as getPds,
+  getFeedGenEndpoint as getFeedGen,
+  getNotifEndpoint as getNotif,
 }
 
 export const getKey = (doc: DidDocument): string | undefined => {
-  const did = getDid(doc)
-  let keys = doc.verificationMethod
-  if (!keys) return undefined
-  if (typeof keys !== 'object') return undefined
-  if (!Array.isArray(keys)) {
-    keys = [keys]
-  }
-  const found = keys.find(
-    (key) => key.id === '#atproto' || key.id === `${did}#atproto`,
-  )
-  if (!found) return undefined
+  const key = getSigningKey(doc)
+  if (!key) return undefined
 
-  // @TODO support jwk
-  // should we be surfacing errors here or returning undefined?
-  if (!found.publicKeyMultibase) return undefined
-  const keyBytes = crypto.multibaseToBytes(found.publicKeyMultibase)
+  const keyBytes = crypto.multibaseToBytes(key.publicKeyMultibase)
   let didKey: string | undefined = undefined
-  if (found.type === 'EcdsaSecp256r1VerificationKey2019') {
+  if (key.type === 'EcdsaSecp256r1VerificationKey2019') {
     didKey = crypto.formatDidKey(crypto.P256_JWT_ALG, keyBytes)
-  } else if (found.type === 'EcdsaSecp256k1VerificationKey2019') {
+  } else if (key.type === 'EcdsaSecp256k1VerificationKey2019') {
     didKey = crypto.formatDidKey(crypto.SECP256K1_JWT_ALG, keyBytes)
-  } else if (found.type === 'Multikey') {
-    const parsed = crypto.parseMultikey(found.publicKeyMultibase)
+  } else if (key.type === 'Multikey') {
+    const parsed = crypto.parseMultikey(key.publicKeyMultibase)
     didKey = crypto.formatDidKey(parsed.jwtAlg, parsed.keyBytes)
   }
   return didKey
 }
 
-export const getHandle = (doc: DidDocument): string | undefined => {
-  const aka = doc.alsoKnownAs
-  if (!aka) return undefined
-  const found = aka.find((name) => name.startsWith('at://'))
-  if (!found) return undefined
-  // strip off at:// prefix
-  return found.slice(5)
-}
-
-export const getPds = (doc: DidDocument): string | undefined => {
-  return getServiceEndpoint(doc, {
-    id: '#atproto_pds',
-    type: 'AtprotoPersonalDataServer',
-  })
-}
-
-export const getFeedGen = (doc: DidDocument): string | undefined => {
-  return getServiceEndpoint(doc, {
-    id: '#bsky_fg',
-    type: 'BskyFeedGenerator',
-  })
-}
-
-export const getNotif = (doc: DidDocument): string | undefined => {
-  return getServiceEndpoint(doc, {
-    id: '#bsky_notif',
-    type: 'BskyNotificationService',
-  })
-}
-
 export const parseToAtprotoDocument = (
   doc: DidDocument,
 ): Partial<AtprotoData> => {
@@ -76,7 +42,7 @@ export const parseToAtprotoDocument = (
     did,
     signingKey: getKey(doc),
     handle: getHandle(doc),
-    pds: getPds(doc),
+    pds: getPdsEndpoint(doc),
   }
 }
 
@@ -97,38 +63,10 @@ export const ensureAtpDocument = (doc: DidDocument): AtprotoData => {
   return { did, signingKey, handle, pds }
 }
 
-// Check protocol and hostname to prevent potential SSRF
-const validateUrl = (url: string) => {
-  const { hostname, protocol } = new URL(url)
-  if (!['http:', 'https:'].includes(protocol)) {
-    throw new Error('Invalid pds protocol')
-  }
-  if (!hostname) {
-    throw new Error('Invalid pds hostname')
-  }
-}
-
-const getServiceEndpoint = (
-  doc: DidDocument,
-  opts: { id: string; type: string },
-) => {
-  const did = getDid(doc)
-  let services = doc.service
-  if (!services) return undefined
-  if (typeof services !== 'object') return undefined
-  if (!Array.isArray(services)) {
-    services = [services]
-  }
-  const found = services.find(
-    (service) => service.id === opts.id || service.id === `${did}${opts.id}`,
-  )
-  if (!found) return undefined
-  if (found.type !== opts.type) {
-    return undefined
-  }
-  if (typeof found.serviceEndpoint !== 'string') {
-    return undefined
+export const ensureAtprotoKey = (doc: DidDocument): string => {
+  const { signingKey } = parseToAtprotoDocument(doc)
+  if (!signingKey) {
+    throw new Error(`Could not parse signingKey from doc: ${doc}`)
   }
-  validateUrl(found.serviceEndpoint)
-  return found.serviceEndpoint
+  return signingKey
 }

package/src/did/base-resolver.ts

@@ -1,6 +1,12 @@
 import * as crypto from '@atproto/crypto'
 import { check } from '@atproto/common-web'
-import { DidCache, AtprotoData, DidDocument, didDocument } from '../types'
+import {
+  DidCache,
+  AtprotoData,
+  DidDocument,
+  didDocument,
+  CacheResult,
+} from '../types'
 import * as atprotoData from './atproto-data'
 import { DidNotFoundError, PoorlyFormattedDidDocumentError } from '../errors'
 
@@ -25,20 +31,25 @@ export abstract class BaseResolver {
     return this.validateDidDoc(did, got)
   }
 
-  async refreshCache(did: string): Promise<void> {
-    await this.cache?.refreshCache(did, () => this.resolveNoCache(did))
+  async refreshCache(did: string, prevResult?: CacheResult): Promise<void> {
+    await this.cache?.refreshCache(
+      did,
+      () => this.resolveNoCache(did),
+      prevResult,
+    )
   }
 
   async resolve(
     did: string,
     forceRefresh = false,
   ): Promise<DidDocument | null> {
+    let fromCache: CacheResult | null = null
     if (this.cache && !forceRefresh) {
-      const fromCache = await this.cache.checkCache(did)
-      if (fromCache?.stale) {
-        await this.refreshCache(did)
-      }
-      if (fromCache) {
+      fromCache = await this.cache.checkCache(did)
+      if (fromCache && !fromCache.expired) {
+        if (fromCache?.stale) {
+          await this.refreshCache(did, fromCache)
+        }
         return fromCache.doc
       }
     }
@@ -48,7 +59,7 @@ export abstract class BaseResolver {
       await this.cache?.clearEntry(did)
       return null
     }
-    await this.cache?.cacheDid(did, got)
+    await this.cache?.cacheDid(did, got, fromCache ?? undefined)
     return got
   }
 
@@ -72,8 +83,8 @@ export abstract class BaseResolver {
     if (did.startsWith('did:key:')) {
       return did
     } else {
-      const data = await this.resolveAtprotoData(did, forceRefresh)
-      return data.signingKey
+      const didDocument = await this.ensureResolve(did, forceRefresh)
+      return atprotoData.ensureAtprotoKey(didDocument)
     }
   }
 

package/src/did/memory-cache.ts

@@ -35,13 +35,12 @@ export class MemoryCache implements DidCache {
     if (!val) return null
     const now = Date.now()
     const expired = now > val.updatedAt + this.maxTTL
-    if (expired) return null
-
     const stale = now > val.updatedAt + this.staleTTL
     return {
       ...val,
       did,
       stale,
+      expired,
     }
   }
 

package/src/handle/index.ts

@@ -50,7 +50,7 @@ export class HandleResolver {
     const url = new URL('/.well-known/atproto-did', `https://${handle}`)
     try {
       const res = await fetch(url, { signal })
-      const did = await res.text()
+      const did = (await res.text()).split('\n')[0].trim()
       if (typeof did === 'string' && did.startsWith('did:')) {
         return did
       }

package/src/types.ts

@@ -1,4 +1,7 @@
-import * as z from 'zod'
+import { DidDocument } from '@atproto/common-web'
+
+export { didDocument } from '@atproto/common-web'
+export type { DidDocument } from '@atproto/common-web'
 
 export type IdentityResolverOpts = {
   timeout?: number
@@ -30,37 +33,21 @@ export type CacheResult = {
   doc: DidDocument
   updatedAt: number
   stale: boolean
+  expired: boolean
 }
 
 export interface DidCache {
-  cacheDid(did: string, doc: DidDocument): Promise<void>
+  cacheDid(
+    did: string,
+    doc: DidDocument,
+    prevResult?: CacheResult,
+  ): Promise<void>
   checkCache(did: string): Promise<CacheResult | null>
   refreshCache(
     did: string,
     getDoc: () => Promise<DidDocument | null>,
+    prevResult?: CacheResult,
   ): Promise<void>
   clearEntry(did: string): Promise<void>
   clear(): Promise<void>
 }
-
-export const verificationMethod = z.object({
-  id: z.string(),
-  type: z.string(),
-  controller: z.string(),
-  publicKeyMultibase: z.string().optional(),
-})
-
-export const service = z.object({
-  id: z.string(),
-  type: z.string(),
-  serviceEndpoint: z.union([z.string(), z.record(z.unknown())]),
-})
-
-export const didDocument = z.object({
-  id: z.string(),
-  alsoKnownAs: z.array(z.string()).optional(),
-  verificationMethod: z.array(verificationMethod).optional(),
-  service: z.array(service).optional(),
-})
-
-export type DidDocument = z.infer<typeof didDocument>

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022-2023 Bluesky PBC
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.