@sphereon/ssi-sdk-ext.identifier-resolution 0.28.1-feature.jose.vcdm.52 → 0.28.1-feature.oyd.cmsm.improv.20

package/src/agent/IdentifierResolution.ts

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

package/src/functions/LegacySupport.ts

@@ -1,5 +1,5 @@
-import type { IIdentifier } from '@veramo/core'
-import type { ManagedIdentifierDidOpts, ManagedIdentifierOptsOrResult } from '../types'
+import { IIdentifier } from '@veramo/core'
+import { 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,
-  type X509ValidationResult,
+  X509ValidationResult,
 } from '@sphereon/ssi-sdk-ext.x509-utils'
 import { contextHasPlugin } from '@sphereon/ssi-sdk.agent-config'
-import { type IParsedDID, type JWK, parseDid } from '@sphereon/ssi-types'
-import type { IAgentContext, IDIDManager, IResolver } from '@veramo/core'
+import { IParsedDID, JWK, parseDid } from '@sphereon/ssi-types'
+import { IAgentContext, IDIDManager, IResolver } from '@veramo/core'
 import { isDefined } from '@veramo/utils'
 import { CryptoEngine, setEngine } from 'pkijs'
-import type {
+import {
   ExternalIdentifierCoseKeyOpts,
   ExternalIdentifierCoseKeyResult,
   ExternalIdentifierDidOpts,
@@ -25,8 +25,6 @@ import type {
   ExternalIdentifierX5cOpts,
   ExternalIdentifierX5cResult,
   ExternalJwkInfo,
-} from '../types'
-import {
   isExternalIdentifierCoseKeyOpts,
   isExternalIdentifierDidOpts,
   isExternalIdentifierJwkOpts,
@@ -38,10 +36,9 @@ import {
 } from '../types'
 import { resolveExternalOIDFEntityIdIdentifier } from '.'
 
-import { webcrypto } from 'node:crypto'
 export async function resolveExternalIdentifier(
   opts: ExternalIdentifierOpts & {
-    crypto?: webcrypto.Crypto
+    crypto?: Crypto
   },
   context: IAgentContext<any>
 ): Promise<ExternalIdentifierResult> {
@@ -68,7 +65,7 @@ export async function resolveExternalIdentifier(
 
 export async function resolveExternalX5cIdentifier(
   opts: ExternalIdentifierX5cOpts & {
-    crypto?: webcrypto.Crypto
+    crypto?: Crypto
   },
   context: IAgentContext<IResolver & IDIDManager>
 ): Promise<ExternalIdentifierX5cResult> {
@@ -248,24 +245,18 @@ 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,11 +1,9 @@
-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 { ErrorMessage, ExternalIdentifierOIDFEntityIdOpts, ExternalIdentifierOIDFEntityIdResult, ExternalJwkInfo, TrustedAnchor } from '../types'
+import { IAgentContext } from '@veramo/core'
+import { IOIDFClient } from '@sphereon/ssi-sdk.oidf-client'
 import { contextHasPlugin } from '@sphereon/ssi-sdk.agent-config'
-import type { IJwsValidationResult, JwsPayload } from '../types/IJwtService'
-// @ts-ignore
+import {IJwsValidationResult, JwsPayload} from '../types/IJwtService'
 import * as u8a from 'uint8arrays'
-const { fromString, toString } = u8a
 /**
  * Resolves an OIDF Entity ID against multiple trust anchors to establish trusted relationships
  *
@@ -45,10 +43,10 @@ export async function resolveExternalOIDFEntityIdIdentifier(
       trustAnchors: [trustAnchor],
     })
 
-    if (resolveResult.errorMessage || !resolveResult.trustChain) {
+    if (resolveResult.error || !resolveResult.trustChain) {
       errorList[trustAnchor] = resolveResult.errorMessage ?? 'unspecified'
     } else {
-      const trustChain = resolveResult.trustChain
+      const trustChain: ReadonlyArray<string> = resolveResult.trustChain.asJsReadonlyArrayView()
       if (trustChain.length === 0) {
         errorList[trustAnchor] = 'Trust chain is empty'
         continue
@@ -67,7 +65,7 @@ export async function resolveExternalOIDFEntityIdIdentifier(
         continue
       }
 
-      payload = JSON.parse(toString(fromString(jwtVerifyResult.jws.payload, 'base64url')))
+      payload = JSON.parse(u8a.toString(u8a.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,12 +2,21 @@ 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 type { ICoseKeyJson, JWK } from '@sphereon/ssi-types'
-import type { IAgentContext, IIdentifier, IKey, IKeyManager } from '@veramo/core'
+import { ICoseKeyJson, JWK } from '@sphereon/ssi-types'
+import { IAgentContext, IIdentifier, IKey, IKeyManager } from '@veramo/core'
 import { CryptoEngine, setEngine } from 'pkijs'
-import { webcrypto } from 'node:crypto'
-import type {
+import {
   IIdentifierResolution,
+  isManagedIdentifierCoseKeyOpts,
+  isManagedIdentifierDidOpts,
+  isManagedIdentifierDidResult,
+  isManagedIdentifierOID4VCIssuerOpts,
+  isManagedIdentifierJwkOpts,
+  isManagedIdentifierJwkResult,
+  isManagedIdentifierKeyOpts,
+  isManagedIdentifierKeyResult,
+  isManagedIdentifierKidOpts,
+  isManagedIdentifierX5cOpts,
   ManagedIdentifierCoseKeyOpts,
   ManagedIdentifierCoseKeyResult,
   ManagedIdentifierDidOpts,
@@ -26,19 +35,6 @@ import type {
   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>
@@ -51,13 +47,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 })
@@ -84,7 +80,7 @@ export async function getManagedKidIdentifier(
 
 export function isManagedIdentifierResult(
   identifier: ManagedIdentifierOptsOrResult & {
-    crypto?: webcrypto.Crypto
+    crypto?: Crypto
   }
 ): identifier is ManagedIdentifierResult {
   return 'key' in identifier && 'kmsKeyRef' in identifier && 'method' in identifier && 'opts' in identifier && 'jwkThumbprint' in identifier
@@ -97,7 +93,7 @@ export function isManagedIdentifierResult(
  */
 export async function ensureManagedIdentifierResult(
   identifier: ManagedIdentifierOptsOrResult & {
-    crypto?: webcrypto.Crypto
+    crypto?: Crypto
   },
   context: IAgentContext<IKeyManager>
 ): Promise<ManagedIdentifierResult> {
@@ -187,8 +183,6 @@ 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',
     },
@@ -253,7 +247,7 @@ export async function getManagedJwkIdentifier(
 
 export async function getManagedX5cIdentifier(
   opts: ManagedIdentifierX5cOpts & {
-    crypto?: webcrypto.Crypto
+    crypto?: Crypto
   },
   context: IAgentContext<IKeyManager>
 ): Promise<ManagedIdentifierX5cResult> {
@@ -337,7 +331,7 @@ export async function getManagedOID4VCIssuerIdentifier(
 
 export async function getManagedIdentifier(
   opts: ManagedIdentifierOptsOrResult & {
-    crypto?: webcrypto.Crypto
+    crypto?: 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 type { IAgentContext, IDIDManager, IKeyManager, IPluginMethodMap } from '@veramo/core'
-import type {
+import { IAgentContext, IDIDManager, IKeyManager, IPluginMethodMap } from '@veramo/core'
+import {
   ExternalIdentifierCoseKeyOpts,
   ExternalIdentifierCoseKeyResult,
   ExternalIdentifierDidOpts,
@@ -13,7 +13,7 @@ import type {
   ExternalIdentifierX5cOpts,
   ExternalIdentifierX5cResult,
 } from './externalIdentifierTypes'
-import type {
+import {
   ManagedIdentifierCoseKeyOpts,
   ManagedIdentifierCoseKeyResult,
   ManagedIdentifierDidOpts,
@@ -41,7 +41,7 @@ export const identifierResolutionContextMethods: Array<string> = [
   'identifierManagedGetByX5c',
   'identifierManagedGetByKey',
   'identifierManagedGetByOID4VCIssuer',
-  'identifierManagedGetByCoseKey',
+  'identifierGetManagedByCoseKey',
   '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 '../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'
+} 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'
 export type IRequiredContext = IAgentContext<IIdentifierResolution & IKeyManager>
 export declare const jwtServiceContextMethods: Array<string>
 export interface IJwtService extends IPluginMethodMap {
@@ -25,7 +25,6 @@ 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 type { ICoseKeyJson, JWK } from '@sphereon/ssi-types'
-import type { IIdentifier, IKey } from '@veramo/core'
-import type { ExternalIdentifierType } from './externalIdentifierTypes'
-import type { ManagedIdentifierType } from './managedIdentifierTypes'
+import { ICoseKeyJson, JWK } from '@sphereon/ssi-types'
+import { IIdentifier, IKey } from '@veramo/core'
+import { ExternalIdentifierType } from './externalIdentifierTypes'
+import { ManagedIdentifierType } from './managedIdentifierTypes'
 
 export interface JwkInfo {
   jwk: JWK

package/src/types/externalIdentifierTypes.ts

@@ -1,8 +1,8 @@
-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 { 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 {
   isCoseKeyIdentifier,
   isDidIdentifier,
@@ -12,9 +12,9 @@ import {
   isKidIdentifier,
   isOidcDiscoveryIdentifier,
   isX5cIdentifier,
-  type JwkInfo,
+  JwkInfo,
 } from './common'
-import type { JwsPayload } from './IJwtService'
+import {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 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 { ClientIdScheme } from '@sphereon/ssi-sdk-ext.x509-utils'
+import { ICoseKeyJson, JWK } from '@sphereon/ssi-types'
+import { DIDDocumentSection, IIdentifier, IKey, TKeyType } from '@veramo/core'
 import {
   isCoseKeyIdentifier,
   isDidIdentifier,
@@ -9,7 +9,7 @@ import {
   isKeyIdentifier,
   isKidIdentifier,
   isX5cIdentifier,
-  type JwkInfo,
+  JwkInfo,
 } from './common'
 
 /**