@sphereon/ssi-sdk-ext.identifier-resolution 0.28.1-feature.oyd.cmsm.improv.21 → 0.28.1-next.53

package/src/agent/IdentifierResolution.ts

@@ -1,9 +1,9 @@
 import { globalCrypto } from '@sphereon/ssi-sdk-ext.key-utils'
-import { IAgentContext, IAgentPlugin, IDIDManager, IKeyManager } from '@veramo/core'
-import { ExternalIdentifierOIDFEntityIdOpts, ExternalIdentifierOIDFEntityIdResult } from '../types'
-import { schema } from '..'
+import type { IAgentContext, IAgentPlugin, IDIDManager, IKeyManager } from '@veramo/core'
+import type { ExternalIdentifierOIDFEntityIdOpts, ExternalIdentifierOIDFEntityIdResult } from '../types'
+import { schema } from '../index'
 import { resolveExternalIdentifier, ensureManagedIdentifierResult } from '../functions'
-import {
+import type {
   ExternalIdentifierDidOpts,
   ExternalIdentifierDidResult,
   ExternalIdentifierOpts,
@@ -32,26 +32,28 @@ import {
   ManagedIdentifierOptsOrResult,
   ManagedIdentifierOID4VCIssuerOpts,
 } from '../types'
-import { IOIDFClient } from '@sphereon/ssi-sdk.oidf-client'
+import type { IOIDFClient } from '@sphereon/ssi-sdk.oidf-client'
+
+import { webcrypto } from 'node:crypto'
 
 /**
  * @public
  */
 export class IdentifierResolution implements IAgentPlugin {
-  private readonly _crypto: Crypto
+  readonly _crypto: webcrypto.Crypto
 
   readonly schema = schema.IMnemonicInfoGenerator
   readonly methods: IIdentifierResolution = {
-    identifierManagedGet: this.identifierGetManaged.bind(this),
-    identifierManagedGetByDid: this.identifierGetManagedByDid.bind(this),
-    identifierManagedGetByKid: this.identifierGetManagedByKid.bind(this),
-    identifierManagedGetByJwk: this.identifierGetManagedByJwk.bind(this),
-    identifierManagedGetByX5c: this.identifierGetManagedByX5c.bind(this),
-    identifierManagedGetByKey: this.identifierGetManagedByKey.bind(this),
-    identifierManagedGetByCoseKey: this.identifierGetManagedByCoseKey.bind(this),
-    identifierManagedGetByOID4VCIssuer: this.identifierGetManagedByOID4VCIssuer.bind(this),
-
-    identifierExternalResolve: this.identifierResolveExternal.bind(this),
+    identifierManagedGet: this.identifierManagedGet.bind(this),
+    identifierManagedGetByDid: this.identifierManagedGetByDid.bind(this),
+    identifierManagedGetByKid: this.identifierManagedGetByKid.bind(this),
+    identifierManagedGetByJwk: this.identifierManagedGetByJwk.bind(this),
+    identifierManagedGetByX5c: this.identifierManagedGetByX5c.bind(this),
+    identifierManagedGetByKey: this.identifierManagedGetByKey.bind(this),
+    identifierManagedGetByCoseKey: this.identifierManagedGetByCoseKey.bind(this),
+    identifierManagedGetByOID4VCIssuer: this.identifierManagedGetByOID4VCIssuer.bind(this),
+
+    identifierExternalResolve: this.identifierExternalResolve.bind(this),
     identifierExternalResolveByDid: this.identifierExternalResolveByDid.bind(this),
     identifierExternalResolveByX5c: this.identifierExternalResolveByX5c.bind(this),
     identifierExternalResolveByJwk: this.identifierExternalResolveByJwk.bind(this),
@@ -64,7 +66,7 @@ export class IdentifierResolution implements IAgentPlugin {
   /**
    * TODO: Add a cache, as we are retrieving the same keys/info quite often
    */
-  constructor(opts?: { crypto?: Crypto }) {
+  constructor(opts?: { crypto?: webcrypto.Crypto }) {
     this._crypto = globalCrypto(false, opts?.crypto)
   }
 
@@ -73,65 +75,64 @@ export class IdentifierResolution implements IAgentPlugin {
    * integrate a plugin for anomaly detection. Having a single method helps
    * @param args
    * @param context
-   * @private
    */
-  private async identifierGetManaged(
+  private async identifierManagedGet(
     args: ManagedIdentifierOptsOrResult,
     context: IAgentContext<IKeyManager & IIdentifierResolution>
   ): Promise<ManagedIdentifierResult> {
     return await ensureManagedIdentifierResult({ ...args, crypto: this._crypto }, context)
   }
 
-  private async identifierGetManagedByDid(
+  private async identifierManagedGetByDid(
     args: ManagedIdentifierDidOpts,
     context: IAgentContext<IKeyManager & IDIDManager & IIdentifierResolution>
   ): Promise<ManagedIdentifierDidResult> {
-    return (await this.identifierGetManaged({ ...args, method: 'did' }, context)) as ManagedIdentifierDidResult
+    return (await this.identifierManagedGet({ ...args, method: 'did' }, context)) as ManagedIdentifierDidResult
   }
 
-  private async identifierGetManagedByKid(
+  private async identifierManagedGetByKid(
     args: ManagedIdentifierKidOpts,
     context: IAgentContext<IKeyManager & IIdentifierResolution>
   ): Promise<ManagedIdentifierKidResult> {
-    return (await this.identifierGetManaged({ ...args, method: 'kid' }, context)) as ManagedIdentifierKidResult
+    return (await this.identifierManagedGet({ ...args, method: 'kid' }, context)) as ManagedIdentifierKidResult
   }
 
-  private async identifierGetManagedByKey(
+  private async identifierManagedGetByKey(
     args: ManagedIdentifierKeyOpts,
     context: IAgentContext<IKeyManager & IIdentifierResolution>
   ): Promise<ManagedIdentifierKeyResult> {
-    return (await this.identifierGetManaged({ ...args, method: 'key' }, context)) as ManagedIdentifierKeyResult
+    return (await this.identifierManagedGet({ ...args, method: 'key' }, context)) as ManagedIdentifierKeyResult
   }
 
-  private async identifierGetManagedByCoseKey(
+  private async identifierManagedGetByCoseKey(
     args: ManagedIdentifierCoseKeyOpts,
     context: IAgentContext<IKeyManager & IIdentifierResolution>
   ): Promise<ManagedIdentifierCoseKeyResult> {
-    return (await this.identifierGetManaged({ ...args, method: 'cose_key' }, context)) as ManagedIdentifierCoseKeyResult
+    return (await this.identifierManagedGet({ ...args, method: 'cose_key' }, context)) as ManagedIdentifierCoseKeyResult
   }
 
-  private async identifierGetManagedByOID4VCIssuer(
+  private async identifierManagedGetByOID4VCIssuer(
     args: ManagedIdentifierOID4VCIssuerOpts,
     context: IAgentContext<IKeyManager & IIdentifierResolution>
   ): Promise<ManagedIdentifierOID4VCIssuerResult> {
-    return (await this.identifierGetManaged({ ...args, method: 'oid4vci-issuer' }, context)) as ManagedIdentifierOID4VCIssuerResult
+    return (await this.identifierManagedGet({ ...args, method: 'oid4vci-issuer' }, context)) as ManagedIdentifierOID4VCIssuerResult
   }
 
-  private async identifierGetManagedByJwk(
+  private async identifierManagedGetByJwk(
     args: ManagedIdentifierJwkOpts,
     context: IAgentContext<IKeyManager & IIdentifierResolution>
   ): Promise<ManagedIdentifierJwkResult> {
-    return (await this.identifierGetManaged({ ...args, method: 'jwk' }, context)) as ManagedIdentifierJwkResult
+    return (await this.identifierManagedGet({ ...args, method: 'jwk' }, context)) as ManagedIdentifierJwkResult
   }
 
-  private async identifierGetManagedByX5c(
+  private async identifierManagedGetByX5c(
     args: ManagedIdentifierX5cOpts,
     context: IAgentContext<IKeyManager & IIdentifierResolution>
   ): Promise<ManagedIdentifierX5cResult> {
-    return (await this.identifierGetManaged({ ...args, method: 'x5c' }, context)) as ManagedIdentifierX5cResult
+    return (await this.identifierManagedGet({ ...args, method: 'x5c' }, context)) as ManagedIdentifierX5cResult
   }
 
-  private async identifierResolveExternal(
+  private async identifierExternalResolve(
     args: ExternalIdentifierOpts,
     context: IAgentContext<IKeyManager | IOIDFClient>
   ): Promise<ExternalIdentifierResult> {
@@ -139,28 +140,28 @@ export class IdentifierResolution implements IAgentPlugin {
   }
 
   private async identifierExternalResolveByDid(args: ExternalIdentifierDidOpts, context: IAgentContext<any>): Promise<ExternalIdentifierDidResult> {
-    return (await this.identifierResolveExternal({ ...args, method: 'did' }, context)) as ExternalIdentifierDidResult
+    return (await this.identifierExternalResolve({ ...args, method: 'did' }, context)) as ExternalIdentifierDidResult
   }
 
   private async identifierExternalResolveByX5c(args: ExternalIdentifierX5cOpts, context: IAgentContext<any>): Promise<ExternalIdentifierX5cResult> {
-    return (await this.identifierResolveExternal({ ...args, method: 'x5c' }, context)) as ExternalIdentifierX5cResult
+    return (await this.identifierExternalResolve({ ...args, method: 'x5c' }, context)) as ExternalIdentifierX5cResult
   }
 
   private async identifierExternalResolveByCoseKey(
     args: ExternalIdentifierCoseKeyOpts,
     context: IAgentContext<any>
   ): Promise<ExternalIdentifierCoseKeyResult> {
-    return (await this.identifierResolveExternal({ ...args, method: 'cose_key' }, context)) as ExternalIdentifierCoseKeyResult
+    return (await this.identifierExternalResolve({ ...args, method: 'cose_key' }, context)) as ExternalIdentifierCoseKeyResult
   }
 
   private async identifierExternalResolveByJwk(args: ExternalIdentifierJwkOpts, context: IAgentContext<any>): Promise<ExternalIdentifierJwkResult> {
-    return (await this.identifierResolveExternal({ ...args, method: 'jwk' }, context)) as ExternalIdentifierJwkResult
+    return (await this.identifierExternalResolve({ ...args, method: 'jwk' }, context)) as ExternalIdentifierJwkResult
   }
 
   private async identifierExternalResolveByOIDFEntityId(
     args: ExternalIdentifierOIDFEntityIdOpts,
     context: IAgentContext<any>
   ): Promise<ExternalIdentifierOIDFEntityIdResult> {
-    return (await this.identifierResolveExternal({ ...args, method: 'entity_id' }, context)) as ExternalIdentifierOIDFEntityIdResult
+    return (await this.identifierExternalResolve({ ...args, method: 'entity_id' }, context)) as ExternalIdentifierOIDFEntityIdResult
   }
 }

package/src/functions/LegacySupport.ts

@@ -1,5 +1,5 @@
-import { IIdentifier } from '@veramo/core'
-import { ManagedIdentifierDidOpts, ManagedIdentifierOptsOrResult } from '../types'
+import type { IIdentifier } from '@veramo/core'
+import type { ManagedIdentifierDidOpts, ManagedIdentifierOptsOrResult } from '../types'
 
 /**
  * Converts legacy id opts key refs to the new ManagedIdentifierOpts

package/src/functions/externalIdentifierFunctions.ts

@@ -5,14 +5,14 @@ import {
   pemOrDerToX509Certificate,
   PEMToDer,
   validateX509CertificateChain,
-  X509ValidationResult,
+  type X509ValidationResult,
 } from '@sphereon/ssi-sdk-ext.x509-utils'
 import { contextHasPlugin } from '@sphereon/ssi-sdk.agent-config'
-import { IParsedDID, JWK, parseDid } from '@sphereon/ssi-types'
-import { IAgentContext, IDIDManager, IResolver } from '@veramo/core'
+import { type IParsedDID, type JWK, parseDid } from '@sphereon/ssi-types'
+import type { IAgentContext, IDIDManager, IResolver } from '@veramo/core'
 import { isDefined } from '@veramo/utils'
 import { CryptoEngine, setEngine } from 'pkijs'
-import {
+import type {
   ExternalIdentifierCoseKeyOpts,
   ExternalIdentifierCoseKeyResult,
   ExternalIdentifierDidOpts,
@@ -25,6 +25,8 @@ import {
   ExternalIdentifierX5cOpts,
   ExternalIdentifierX5cResult,
   ExternalJwkInfo,
+} from '../types'
+import {
   isExternalIdentifierCoseKeyOpts,
   isExternalIdentifierDidOpts,
   isExternalIdentifierJwkOpts,
@@ -36,9 +38,10 @@ import {
 } from '../types'
 import { resolveExternalOIDFEntityIdIdentifier } from '.'
 
+import { webcrypto } from 'node:crypto'
 export async function resolveExternalIdentifier(
   opts: ExternalIdentifierOpts & {
-    crypto?: Crypto
+    crypto?: webcrypto.Crypto
   },
   context: IAgentContext<any>
 ): Promise<ExternalIdentifierResult> {
@@ -65,7 +68,7 @@ export async function resolveExternalIdentifier(
 
 export async function resolveExternalX5cIdentifier(
   opts: ExternalIdentifierX5cOpts & {
-    crypto?: Crypto
+    crypto?: webcrypto.Crypto
   },
   context: IAgentContext<IResolver & IDIDManager>
 ): Promise<ExternalIdentifierX5cResult> {
@@ -245,18 +248,24 @@ export async function resolveExternalDidIdentifier(
   const didDocument = didResolutionResult.didDocument ?? undefined
   const didJwks = didDocument ? didDocumentToJwks(didDocument) : undefined
   const jwks = didJwks
-    ? Array.from(new Set(Array.from(
-          Object.values(didJwks)
-            .filter((jwks) => isDefined(jwks) && jwks.length > 0)
-            .flatMap((jwks) => jwks)
-      ).flatMap((jwk) => {
-        return {
-          jwk,
-          jwkThumbprint: calculateJwkThumbprint({ jwk }),
-          kid: jwk.kid,
-          publicKeyHex: jwkTtoPublicKeyHex(jwk),
-        }
-      }).map(jwk => JSON.stringify(jwk)))).map((jwks) => JSON.parse(jwks))
+    ? Array.from(
+        new Set(
+          Array.from(
+            Object.values(didJwks)
+              .filter((jwks) => isDefined(jwks) && jwks.length > 0)
+              .flatMap((jwks) => jwks)
+          )
+            .flatMap((jwk) => {
+              return {
+                jwk,
+                jwkThumbprint: calculateJwkThumbprint({ jwk }),
+                kid: jwk.kid,
+                publicKeyHex: jwkTtoPublicKeyHex(jwk),
+              }
+            })
+            .map((jwk) => JSON.stringify(jwk))
+        )
+      ).map((jwks) => JSON.parse(jwks))
     : []
 
   if (didResolutionResult?.didDocument) {

package/src/functions/externalOIDFIdentifier.ts

@@ -1,9 +1,11 @@
-import { ErrorMessage, ExternalIdentifierOIDFEntityIdOpts, ExternalIdentifierOIDFEntityIdResult, ExternalJwkInfo, TrustedAnchor } from '../types'
-import { IAgentContext } from '@veramo/core'
-import { IOIDFClient } from '@sphereon/ssi-sdk.oidf-client'
+import type { ErrorMessage, ExternalIdentifierOIDFEntityIdOpts, ExternalIdentifierOIDFEntityIdResult, ExternalJwkInfo, TrustedAnchor } from '../types'
+import type { IAgentContext } from '@veramo/core'
+import type { IOIDFClient } from '@sphereon/ssi-sdk.oidf-client'
 import { contextHasPlugin } from '@sphereon/ssi-sdk.agent-config'
-import {IJwsValidationResult, JwsPayload} from '../types/IJwtService'
+import type { IJwsValidationResult, JwsPayload } from '../types/IJwtService'
+// @ts-ignore
 import * as u8a from 'uint8arrays'
+const { fromString, toString } = u8a
 /**
  * Resolves an OIDF Entity ID against multiple trust anchors to establish trusted relationships
  *
@@ -43,10 +45,10 @@ export async function resolveExternalOIDFEntityIdIdentifier(
       trustAnchors: [trustAnchor],
     })
 
-    if (resolveResult.error || !resolveResult.trustChain) {
+    if (resolveResult.errorMessage || !resolveResult.trustChain) {
       errorList[trustAnchor] = resolveResult.errorMessage ?? 'unspecified'
     } else {
-      const trustChain: ReadonlyArray<string> = resolveResult.trustChain.asJsReadonlyArrayView()
+      const trustChain = resolveResult.trustChain
       if (trustChain.length === 0) {
         errorList[trustAnchor] = 'Trust chain is empty'
         continue
@@ -65,7 +67,7 @@ export async function resolveExternalOIDFEntityIdIdentifier(
         continue
       }
 
-      payload = JSON.parse(u8a.toString(u8a.fromString(jwtVerifyResult.jws.payload, 'base64url')))
+      payload = JSON.parse(toString(fromString(jwtVerifyResult.jws.payload, 'base64url')))
       const signature = jwtVerifyResult.jws.signatures[0]
       if (signature.identifier.jwks.length === 0) {
         errorList[trustAnchor] = 'No JWK was present in the trust anchor signature'

package/src/functions/managedIdentifierFunctions.ts

@@ -2,21 +2,12 @@ import { getFirstKeyWithRelation } from '@sphereon/ssi-sdk-ext.did-utils'
 import { calculateJwkThumbprint, coseKeyToJwk, globalCrypto, toJwk } from '@sphereon/ssi-sdk-ext.key-utils'
 import { pemOrDerToX509Certificate } from '@sphereon/ssi-sdk-ext.x509-utils'
 import { contextHasDidManager, contextHasKeyManager } from '@sphereon/ssi-sdk.agent-config'
-import { ICoseKeyJson, JWK } from '@sphereon/ssi-types'
-import { IAgentContext, IIdentifier, IKey, IKeyManager } from '@veramo/core'
+import type { ICoseKeyJson, JWK } from '@sphereon/ssi-types'
+import type { IAgentContext, IIdentifier, IKey, IKeyManager } from '@veramo/core'
 import { CryptoEngine, setEngine } from 'pkijs'
-import {
+import { webcrypto } from 'node:crypto'
+import type {
   IIdentifierResolution,
-  isManagedIdentifierCoseKeyOpts,
-  isManagedIdentifierDidOpts,
-  isManagedIdentifierDidResult,
-  isManagedIdentifierOID4VCIssuerOpts,
-  isManagedIdentifierJwkOpts,
-  isManagedIdentifierJwkResult,
-  isManagedIdentifierKeyOpts,
-  isManagedIdentifierKeyResult,
-  isManagedIdentifierKidOpts,
-  isManagedIdentifierX5cOpts,
   ManagedIdentifierCoseKeyOpts,
   ManagedIdentifierCoseKeyResult,
   ManagedIdentifierDidOpts,
@@ -35,6 +26,19 @@ import {
   ManagedIdentifierX5cResult,
 } from '../types'
 
+import {
+  isManagedIdentifierCoseKeyOpts,
+  isManagedIdentifierDidOpts,
+  isManagedIdentifierDidResult,
+  isManagedIdentifierOID4VCIssuerOpts,
+  isManagedIdentifierJwkOpts,
+  isManagedIdentifierJwkResult,
+  isManagedIdentifierKeyOpts,
+  isManagedIdentifierKeyResult,
+  isManagedIdentifierKidOpts,
+  isManagedIdentifierX5cOpts,
+} from '../types'
+
 export async function getManagedKidIdentifier(
   opts: ManagedIdentifierKidOpts,
   context: IAgentContext<IKeyManager>
@@ -47,13 +51,13 @@ export async function getManagedKidIdentifier(
     return Promise.reject(Error(`Cannot get Key/JWK identifier if KeyManager plugin is not enabled!`))
   } else if (opts.identifier.startsWith('did:')) {
     const did = opts.identifier.split('#')[0]
-    const didIdentifier = await getManagedDidIdentifier({...opts, method: 'did', identifier: did}, context)
+    const didIdentifier = await getManagedDidIdentifier({ ...opts, method: 'did', identifier: did }, context)
     key = didIdentifier.key
     issuer = didIdentifier.issuer
     kid = opts?.kid ?? (key.meta?.verificationMethod?.id as string) ?? didIdentifier.kid
   }
   if (!key) {
-    key = await context.agent.keyManagerGet({kid: opts.kmsKeyRef ?? opts.identifier})
+    key = await context.agent.keyManagerGet({ kid: opts.kmsKeyRef ?? opts.identifier })
   }
   const jwk = toJwk(key.publicKeyHex, key.type, { key })
   const jwkThumbprint = (key.meta?.jwkThumbprint as string) ?? calculateJwkThumbprint({ jwk })
@@ -80,7 +84,7 @@ export async function getManagedKidIdentifier(
 
 export function isManagedIdentifierResult(
   identifier: ManagedIdentifierOptsOrResult & {
-    crypto?: Crypto
+    crypto?: webcrypto.Crypto
   }
 ): identifier is ManagedIdentifierResult {
   return 'key' in identifier && 'kmsKeyRef' in identifier && 'method' in identifier && 'opts' in identifier && 'jwkThumbprint' in identifier
@@ -93,7 +97,7 @@ export function isManagedIdentifierResult(
  */
 export async function ensureManagedIdentifierResult(
   identifier: ManagedIdentifierOptsOrResult & {
-    crypto?: Crypto
+    crypto?: webcrypto.Crypto
   },
   context: IAgentContext<IKeyManager>
 ): Promise<ManagedIdentifierResult> {
@@ -183,6 +187,8 @@ export async function getManagedDidIdentifier(opts: ManagedIdentifierDidOpts, co
   const extendedKey = await getFirstKeyWithRelation(
     {
       ...opts,
+      // Make sure we use offline mode if no pref was supplied. We are looking for managed DIDs after all. Could be it is not published yet
+      offlineWhenNoDIDRegistered: opts.offlineWhenNoDIDRegistered ?? true,
       identifier,
       vmRelationship: opts.vmRelationship ?? 'verificationMethod',
     },
@@ -247,7 +253,7 @@ export async function getManagedJwkIdentifier(
 
 export async function getManagedX5cIdentifier(
   opts: ManagedIdentifierX5cOpts & {
-    crypto?: Crypto
+    crypto?: webcrypto.Crypto
   },
   context: IAgentContext<IKeyManager>
 ): Promise<ManagedIdentifierX5cResult> {
@@ -331,7 +337,7 @@ export async function getManagedOID4VCIssuerIdentifier(
 
 export async function getManagedIdentifier(
   opts: ManagedIdentifierOptsOrResult & {
-    crypto?: Crypto
+    crypto?: webcrypto.Crypto
   },
   context: IAgentContext<IKeyManager>
 ): Promise<ManagedIdentifierResult> {

package/src/index.ts

@@ -6,6 +6,6 @@ export { schema }
 /**
  * @public
  */
+export * from './types'
 export { IdentifierResolution } from './agent/IdentifierResolution'
 export * from './functions'
-export * from './types'

package/src/types/IIdentifierResolution.ts

@@ -1,5 +1,5 @@
-import { IAgentContext, IDIDManager, IKeyManager, IPluginMethodMap } from '@veramo/core'
-import {
+import type { IAgentContext, IDIDManager, IKeyManager, IPluginMethodMap } from '@veramo/core'
+import type {
   ExternalIdentifierCoseKeyOpts,
   ExternalIdentifierCoseKeyResult,
   ExternalIdentifierDidOpts,
@@ -13,7 +13,7 @@ import {
   ExternalIdentifierX5cOpts,
   ExternalIdentifierX5cResult,
 } from './externalIdentifierTypes'
-import {
+import type {
   ManagedIdentifierCoseKeyOpts,
   ManagedIdentifierCoseKeyResult,
   ManagedIdentifierDidOpts,
@@ -41,7 +41,7 @@ export const identifierResolutionContextMethods: Array<string> = [
   'identifierManagedGetByX5c',
   'identifierManagedGetByKey',
   'identifierManagedGetByOID4VCIssuer',
-  'identifierGetManagedByCoseKey',
+  'identifierManagedGetByCoseKey',
   'identifierExternalResolve',
   'identifierExternalResolveByDid',
   'identifierExternalResolveByX5c',

package/src/types/IJwtService.d.ts

@@ -1,5 +1,5 @@
 // Copy of jwt-service typings since we cannot include that as devDependency due to cyclic dep
-
+/*
 import {
   ExternalIdentifierDidOpts,
   ExternalIdentifierResult,
@@ -7,10 +7,10 @@ import {
   IIdentifierResolution,
   ManagedIdentifierOptsOrResult,
   ManagedIdentifierResult,
-} from '@sphereon/ssi-sdk-ext.identifier-resolution'
-import { ClientIdScheme } from '@sphereon/ssi-sdk-ext.x509-utils'
-import { BaseJWK, IValidationResult, JoseSignatureAlgorithm, JoseSignatureAlgorithmString, JWK } from '@sphereon/ssi-types'
-import { IAgentContext, IKeyManager, IPluginMethodMap } from '@veramo/core'
+} from '../types'*/
+import type { ClientIdScheme } from '@sphereon/ssi-sdk-ext.x509-utils'
+import type { BaseJWK, IValidationResult, JoseSignatureAlgorithm, JoseSignatureAlgorithmString, JWK } from '@sphereon/ssi-types'
+import type { IAgentContext, IKeyManager, IPluginMethodMap } from '@veramo/core'
 export type IRequiredContext = IAgentContext<IIdentifierResolution & IKeyManager>
 export declare const jwtServiceContextMethods: Array<string>
 export interface IJwtService extends IPluginMethodMap {
@@ -25,6 +25,7 @@ export interface IJwtService extends IPluginMethodMap {
 export type IJwsValidationResult = IValidationResult & {
   jws: JwsJsonGeneralWithIdentifiers
 }
+
 export interface PreparedJws {
   protectedHeader: JwsHeader
   payload: Uint8Array

package/src/types/common.ts

@@ -1,7 +1,7 @@
-import { ICoseKeyJson, JWK } from '@sphereon/ssi-types'
-import { IIdentifier, IKey } from '@veramo/core'
-import { ExternalIdentifierType } from './externalIdentifierTypes'
-import { ManagedIdentifierType } from './managedIdentifierTypes'
+import type { ICoseKeyJson, JWK } from '@sphereon/ssi-types'
+import type { IIdentifier, IKey } from '@veramo/core'
+import type { ExternalIdentifierType } from './externalIdentifierTypes'
+import type { ManagedIdentifierType } from './managedIdentifierTypes'
 
 export interface JwkInfo {
   jwk: JWK

package/src/types/externalIdentifierTypes.ts

@@ -1,8 +1,8 @@
-import { DidDocumentJwks } from '@sphereon/ssi-sdk-ext.did-utils'
-import { ICoseKeyJson, JWK } from '@sphereon/ssi-types'
-import { X509CertificateChainValidationOpts, X509ValidationResult } from '@sphereon/ssi-sdk-ext.x509-utils'
-import { IParsedDID } from '@sphereon/ssi-types'
-import { DIDDocument, DIDDocumentSection, DIDResolutionResult } from '@veramo/core'
+import type { DidDocumentJwks } from '@sphereon/ssi-sdk-ext.did-utils'
+import type { ICoseKeyJson, JWK } from '@sphereon/ssi-types'
+import type { X509CertificateChainValidationOpts, X509ValidationResult } from '@sphereon/ssi-sdk-ext.x509-utils'
+import type { IParsedDID } from '@sphereon/ssi-types'
+import type { DIDDocument, DIDDocumentSection, DIDResolutionResult } from '@veramo/core'
 import {
   isCoseKeyIdentifier,
   isDidIdentifier,
@@ -12,9 +12,9 @@ import {
   isKidIdentifier,
   isOidcDiscoveryIdentifier,
   isX5cIdentifier,
-  JwkInfo,
+  type JwkInfo,
 } from './common'
-import {JwsPayload} from "./IJwtService";
+import type { JwsPayload } from './IJwtService'
 
 /**
  * Use whenever we need to resolve an external identifier. We can pass in kids, DIDs, and x5chains

package/src/types/managedIdentifierTypes.ts

@@ -1,6 +1,6 @@
-import { ClientIdScheme } from '@sphereon/ssi-sdk-ext.x509-utils'
-import { ICoseKeyJson, JWK } from '@sphereon/ssi-types'
-import { DIDDocumentSection, IIdentifier, IKey, TKeyType } from '@veramo/core'
+import type { ClientIdScheme } from '@sphereon/ssi-sdk-ext.x509-utils'
+import type { ICoseKeyJson, JWK } from '@sphereon/ssi-types'
+import type { DIDDocumentSection, IIdentifier, IKey, TKeyType } from '@veramo/core'
 import {
   isCoseKeyIdentifier,
   isDidIdentifier,
@@ -9,7 +9,7 @@ import {
   isKeyIdentifier,
   isKidIdentifier,
   isX5cIdentifier,
-  JwkInfo,
+  type JwkInfo,
 } from './common'
 
 /**

package/dist/agent/IdentifierResolution.d.ts

@@ -1,38 +0,0 @@
-import { IAgentPlugin } from '@veramo/core';
-import { IIdentifierResolution } from '../types';
-/**
- * @public
- */
-export declare class IdentifierResolution implements IAgentPlugin {
-    private readonly _crypto;
-    readonly schema: any;
-    readonly methods: IIdentifierResolution;
-    /**
-     * TODO: Add a cache, as we are retrieving the same keys/info quite often
-     */
-    constructor(opts?: {
-        crypto?: Crypto;
-    });
-    /**
-     * Main method for managed identifiers. We always go through this method (also the other methods below) as we want to
-     * integrate a plugin for anomaly detection. Having a single method helps
-     * @param args
-     * @param context
-     * @private
-     */
-    private identifierGetManaged;
-    private identifierGetManagedByDid;
-    private identifierGetManagedByKid;
-    private identifierGetManagedByKey;
-    private identifierGetManagedByCoseKey;
-    private identifierGetManagedByOID4VCIssuer;
-    private identifierGetManagedByJwk;
-    private identifierGetManagedByX5c;
-    private identifierResolveExternal;
-    private identifierExternalResolveByDid;
-    private identifierExternalResolveByX5c;
-    private identifierExternalResolveByCoseKey;
-    private identifierExternalResolveByJwk;
-    private identifierExternalResolveByOIDFEntityId;
-}
-//# sourceMappingURL=IdentifierResolution.d.ts.map

package/dist/agent/IdentifierResolution.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IdentifierResolution.d.ts","sourceRoot":"","sources":["../../src/agent/IdentifierResolution.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,YAAY,EAA4B,MAAM,cAAc,CAAA;AAIpF,OAAO,EAWL,qBAAqB,EAiBtB,MAAM,UAAU,CAAA;AAGjB;;GAEG;AACH,qBAAa,oBAAqB,YAAW,YAAY;IACvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAQ;IAEhC,QAAQ,CAAC,MAAM,MAAgC;IAC/C,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAkBtC;IAED;;OAEG;gBACS,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;IAItC;;;;;;OAMG;YACW,oBAAoB;YAOpB,yBAAyB;YAOzB,yBAAyB;YAOzB,yBAAyB;YAOzB,6BAA6B;YAO7B,kCAAkC;YAOlC,yBAAyB;YAOzB,yBAAyB;YAOzB,yBAAyB;YAOzB,8BAA8B;YAI9B,8BAA8B;YAI9B,kCAAkC;YAOlC,8BAA8B;YAI9B,uCAAuC;CAMtD"}