@atproto/identity 0.2.0 → 0.3.0

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/jest.config.js

@@ -2,5 +2,5 @@ const base = require('../../jest.config.base.js')
 
 module.exports = {
   ...base,
-  displayName: 'Identity'
+  displayName: 'Identity',
 }

package/package.json

@@ -1,34 +1,24 @@
 {
   "name": "@atproto/identity",
-  "version": "0.2.0",
-  "main": "dist/index.js",
+  "version": "0.3.0",
   "license": "MIT",
+  "description": "Library for decentralized identities in atproto using DIDs and handles",
+  "keywords": [
+    "atproto",
+    "did",
+    "identity"
+  ],
+  "homepage": "https://atproto.com",
   "repository": {
     "type": "git",
-    "url": "https://github.com/bluesky-social/atproto.git",
+    "url": "https://github.com/bluesky-social/atproto",
     "directory": "packages/identity"
   },
-  "scripts": {
-    "test": "jest",
-    "test:log": "cat test.log | pino-pretty",
-    "prettier": "prettier --check src/ tests/",
-    "prettier:fix": "prettier --write src/ tests/",
-    "lint": "eslint . --ext .ts,.tsx",
-    "lint:fix": "yarn lint --fix",
-    "verify": "run-p prettier lint",
-    "verify:fix": "yarn prettier:fix && yarn lint:fix",
-    "build": "node ./build.js",
-    "postbuild": "tsc --build tsconfig.build.json",
-    "update-main-to-dist": "node ./update-pkg.js --update-main-to-dist",
-    "update-main-to-src": "node ./update-pkg.js --update-main-to-src",
-    "prepublish": "npm run update-main-to-dist",
-    "postpublish": "npm run update-main-to-src"
-  },
+  "main": "dist/index.js",
   "dependencies": {
-    "@atproto/common-web": "*",
-    "@atproto/crypto": "*",
     "axios": "^0.27.2",
-    "zod": "^3.21.4"
+    "@atproto/common-web": "^0.2.2",
+    "@atproto/crypto": "^0.2.2"
   },
   "devDependencies": {
     "@did-plc/lib": "^0.0.1",
@@ -36,5 +26,13 @@
     "cors": "^2.8.5",
     "express": "^4.18.2",
     "get-port": "^6.1.2"
-  }
-}
+  },
+  "scripts": {
+    "test": "jest",
+    "test:log": "cat test.log | pino-pretty",
+    "build": "node ./build.js",
+    "postbuild": "tsc --build tsconfig.build.json",
+    "update-main-to-dist": "node ../../update-main-to-dist.js packages/identity"
+  },
+  "types": "dist/index.d.ts"
+}

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),
   }
 }
 
@@ -96,39 +62,3 @@ 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
-  }
-  validateUrl(found.serviceEndpoint)
-  return found.serviceEndpoint
-}

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
   }
 

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/tsconfig.build.json

@@ -1,4 +1,4 @@
 {
   "extends": "./tsconfig.json",
   "exclude": ["**/*.spec.ts", "**/*.test.ts"]
-}
+}

package/tsconfig.json

@@ -5,9 +5,9 @@
     "outDir": "./dist", // Your outDir,
     "emitDeclarationOnly": true
   },
-  "include": ["./src","__tests__/**/**.ts"],
+  "include": ["./src", "__tests__/**/**.ts"],
   "references": [
     { "path": "../common/tsconfig.build.json" },
-    { "path": "../crypto/tsconfig.build.json" },
+    { "path": "../crypto/tsconfig.build.json" }
   ]
-}
+}

package/dist/atp-did.d.ts

@@ -1,14 +0,0 @@
-import { DIDDocument } from 'did-resolver';
-export declare type AtpData = {
-    did: string;
-    signingKey: string;
-    recoveryKey: string;
-    handle: string;
-    atpPds: string;
-};
-export declare const getDid: (doc: DIDDocument) => string;
-export declare const getKey: (doc: DIDDocument, id: string) => string | undefined;
-export declare const getHandle: (doc: DIDDocument) => string | undefined;
-export declare const getAtpPds: (doc: DIDDocument) => string | undefined;
-export declare const parseToAtpDocument: (doc: DIDDocument) => Partial<AtpData>;
-export declare const ensureAtpDocument: (doc: DIDDocument) => AtpData;

package/dist/atproto-data.d.ts

@@ -1,7 +0,0 @@
-import { DidDocument, AtprotoData } from './types';
-export declare const getDid: (doc: DidDocument) => string;
-export declare const getKey: (doc: DidDocument) => string | undefined;
-export declare const getHandle: (doc: DidDocument) => string | undefined;
-export declare const getPds: (doc: DidDocument) => string | undefined;
-export declare const parseToAtprotoDocument: (doc: DidDocument) => Partial<AtprotoData>;
-export declare const ensureAtpDocument: (doc: DidDocument) => AtprotoData;

package/dist/base-resolver.d.ts

@@ -1,16 +0,0 @@
-import { AtprotoData, DidDocument } from './types';
-import { DidCache } from './did-cache';
-export declare abstract class BaseResolver {
-    cache?: DidCache | undefined;
-    constructor(cache?: DidCache | undefined);
-    abstract resolveDidNoCheck(did: string): Promise<unknown | null>;
-    validateDidDoc(did: string, val: unknown): DidDocument;
-    resolveDidNoCache(did: string): Promise<DidDocument | null>;
-    refreshCache(did: string): Promise<void>;
-    resolveDid(did: string, forceRefresh?: boolean): Promise<DidDocument | null>;
-    ensureResolveDid(did: string, forceRefresh?: boolean): Promise<DidDocument>;
-    resolveAtprotoData(did: string, forceRefresh?: boolean): Promise<AtprotoData>;
-    resolveAtprotoKey(did: string, forceRefresh?: boolean): Promise<string>;
-    verifySignature(did: string, data: Uint8Array, sig: Uint8Array, forceRefresh?: boolean): Promise<boolean>;
-}
-export default BaseResolver;

package/dist/did/logger.d.ts

@@ -1,2 +0,0 @@
-export declare const logger: import("pino").default.Logger<import("pino").default.LoggerOptions>;
-export default logger;

package/dist/did-cache.d.ts

@@ -1,8 +0,0 @@
-import { CacheResult, DidDocument } from './types';
-export declare abstract class DidCache {
-    abstract cacheDid(did: string, doc: DidDocument): Promise<void>;
-    abstract checkCache(did: string): Promise<CacheResult | null>;
-    abstract refreshCache(did: string, getDoc: () => Promise<DidDocument | null>): Promise<void>;
-    abstract clearEntry(did: string): Promise<void>;
-    abstract clear(): Promise<void>;
-}

package/dist/identity-resolver.d.ts

@@ -1,8 +0,0 @@
-import { HandleResolver } from './handle';
-import DidResolver from './did/did-resolver';
-import { IdentityResolverOpts } from './types';
-export declare class IdentityResolver {
-    handle: HandleResolver;
-    did: DidResolver;
-    constructor(opts?: Partial<IdentityResolverOpts>);
-}

package/dist/logger.d.ts

@@ -1,2 +0,0 @@
-export declare const logger: import("pino").default.Logger<import("pino").default.LoggerOptions>;
-export default logger;

package/dist/memory-cache.d.ts

@@ -1,18 +0,0 @@
-import { DidCache } from './did-cache';
-import { CacheResult, DidDocument } from './types';
-declare type CacheVal = {
-    doc: DidDocument;
-    updatedAt: number;
-};
-export declare class MemoryCache extends DidCache {
-    staleTTL: number;
-    maxTTL: number;
-    constructor(staleTTL?: number, maxTTL?: number);
-    cache: Map<string, CacheVal>;
-    cacheDid(did: string, doc: DidDocument): Promise<void>;
-    refreshCache(did: string, getDoc: () => Promise<DidDocument | null>): Promise<void>;
-    checkCache(did: string): Promise<CacheResult | null>;
-    clearEntry(did: string): Promise<void>;
-    clear(): Promise<void>;
-}
-export {};

package/dist/plc-resolver.d.ts

@@ -1,9 +0,0 @@
-import BaseResolver from './base-resolver';
-import { PlcResolverOpts } from './types';
-import { DidCache } from './did-cache';
-export declare class DidPlcResolver extends BaseResolver {
-    opts: PlcResolverOpts;
-    cache?: DidCache | undefined;
-    constructor(opts: PlcResolverOpts, cache?: DidCache | undefined);
-    resolveDidNoCheck(did: string): Promise<unknown>;
-}

package/dist/resolver.d.ts

@@ -1,9 +0,0 @@
-import { DidResolverOpts } from './types';
-import BaseResolver from './base-resolver';
-import { DidCache } from './did-cache';
-export declare class DidResolver extends BaseResolver {
-    methods: Record<string, BaseResolver>;
-    constructor(opts?: Partial<DidResolverOpts>, cache?: DidCache);
-    resolveDidNoCheck(did: string): Promise<unknown>;
-}
-export default DidResolver;

package/dist/src/atp-did.d.ts

@@ -1,14 +0,0 @@
-import { DIDDocument } from 'did-resolver';
-export declare type AtpData = {
-    did: string;
-    signingKey: string;
-    recoveryKey: string;
-    handle: string;
-    atpPds: string;
-};
-export declare const getDid: (doc: DIDDocument) => string;
-export declare const getKey: (doc: DIDDocument, id: string) => string | undefined;
-export declare const getHandle: (doc: DIDDocument) => string | undefined;
-export declare const getAtpPds: (doc: DIDDocument) => string | undefined;
-export declare const parseToAtpDocument: (doc: DIDDocument) => Partial<AtpData>;
-export declare const ensureAtpDocument: (doc: DIDDocument) => AtpData;

package/dist/src/errors.d.ts

@@ -1,5 +0,0 @@
-import { DIDResolutionResult } from 'did-resolver';
-export declare const error: (errorType: string) => DIDResolutionResult;
-export declare const notFound: () => DIDResolutionResult;
-export declare const invalidDid: () => DIDResolutionResult;
-export declare const unsupported: () => DIDResolutionResult;

package/dist/src/index.d.ts

@@ -1,4 +0,0 @@
-export * as web from './web-resolver';
-export * as plc from './plc-resolver';
-export * from './resolver';
-export * from './atp-did';

package/dist/src/logger.d.ts

@@ -1,2 +0,0 @@
-export declare const logger: import("pino").default.Logger<import("pino").default.LoggerOptions>;
-export default logger;

package/dist/src/plc/resolver.d.ts

@@ -1,6 +0,0 @@
-import { DIDResolver } from 'did-resolver';
-export declare type PlcResolverOptions = {
-    timeout: number;
-    plcUrl: string;
-};
-export declare const makeResolver: (opts: PlcResolverOptions) => DIDResolver;

package/dist/src/plc-resolver.d.ts

@@ -1,6 +0,0 @@
-import { DIDResolver } from 'did-resolver';
-export declare type PlcResolverOptions = {
-    timeout: number;
-    plcUrl: string;
-};
-export declare const makeResolver: (opts: PlcResolverOptions) => DIDResolver;

package/dist/src/resolver.d.ts

@@ -1,14 +0,0 @@
-import { Resolver, DIDDocument, DIDResolutionOptions, DIDResolutionResult } from 'did-resolver';
-import * as atpDid from './atp-did';
-export declare type DidResolverOptions = {
-    timeout: number;
-    plcUrl: string;
-};
-export declare class DidResolver {
-    resolver: Resolver;
-    constructor(opts?: Partial<DidResolverOptions>);
-    resolveDid(did: string, options?: DIDResolutionOptions): Promise<DIDResolutionResult>;
-    ensureResolveDid(did: string, options?: DIDResolutionOptions): Promise<DIDDocument>;
-    resolveAtpData(did: string): Promise<atpDid.AtpData>;
-}
-export declare const resolver: DidResolver;