@sphereon/oid4vci-client 0.10.4-unstable.98 → 0.12.0

package/lib/ProofOfPossessionBuilder.ts

@@ -7,6 +7,7 @@ import {
   Jwt,
   NO_JWT_PROVIDED,
   OpenId4VCIVersion,
+  PoPMode,
   PROOF_CANT_BE_CONSTRUCTED,
   ProofOfPossession,
   ProofOfPossessionCallbacks,
@@ -17,9 +18,11 @@ export class ProofOfPossessionBuilder<DIDDoc> {
   private readonly proof?: ProofOfPossession;
   private readonly callbacks?: ProofOfPossessionCallbacks<DIDDoc>;
   private readonly version: OpenId4VCIVersion;
+  private readonly mode: PoPMode = 'pop';
 
   private kid?: string;
   private jwk?: JWK;
+  private aud?: string | string[];
   private clientId?: string;
   private issuer?: string;
   private jwt?: Jwt;
@@ -34,54 +37,80 @@ export class ProofOfPossessionBuilder<DIDDoc> {
     jwt,
     accessTokenResponse,
     version,
+    mode = 'pop',
   }: {
     proof?: ProofOfPossession;
     callbacks?: ProofOfPossessionCallbacks<DIDDoc>;
     accessTokenResponse?: AccessTokenResponse;
     jwt?: Jwt;
     version: OpenId4VCIVersion;
+    mode?: PoPMode;
   }) {
+    this.mode = mode;
     this.proof = proof;
     this.callbacks = callbacks;
     this.version = version;
     if (jwt) {
       this.withJwt(jwt);
     } else {
-      this.withTyp(version < OpenId4VCIVersion.VER_1_0_11 ? 'jwt' : 'openid4vci-proof+jwt');
+      this.withTyp(version < OpenId4VCIVersion.VER_1_0_11 || mode === 'jwt' ? 'jwt' : 'openid4vci-proof+jwt');
     }
     if (accessTokenResponse) {
       this.withAccessTokenResponse(accessTokenResponse);
     }
   }
 
+  static manual<DIDDoc>({
+    jwt,
+    callbacks,
+    version,
+    mode = 'jwt',
+  }: {
+    jwt?: Jwt;
+    callbacks: ProofOfPossessionCallbacks<DIDDoc>;
+    version: OpenId4VCIVersion;
+    mode?: PoPMode;
+  }): ProofOfPossessionBuilder<DIDDoc> {
+    return new ProofOfPossessionBuilder({ callbacks, jwt, version, mode });
+  }
+
   static fromJwt<DIDDoc>({
     jwt,
     callbacks,
     version,
+    mode = 'pop',
   }: {
     jwt: Jwt;
     callbacks: ProofOfPossessionCallbacks<DIDDoc>;
     version: OpenId4VCIVersion;
+    mode?: PoPMode;
   }): ProofOfPossessionBuilder<DIDDoc> {
-    return new ProofOfPossessionBuilder({ callbacks, jwt, version });
+    return new ProofOfPossessionBuilder({ callbacks, jwt, version, mode });
   }
 
   static fromAccessTokenResponse<DIDDoc>({
     accessTokenResponse,
     callbacks,
     version,
+    mode = 'pop',
   }: {
     accessTokenResponse: AccessTokenResponse;
     callbacks: ProofOfPossessionCallbacks<DIDDoc>;
     version: OpenId4VCIVersion;
+    mode?: PoPMode;
   }): ProofOfPossessionBuilder<DIDDoc> {
-    return new ProofOfPossessionBuilder({ callbacks, accessTokenResponse, version });
+    return new ProofOfPossessionBuilder({ callbacks, accessTokenResponse, version, mode });
   }
 
   static fromProof<DIDDoc>(proof: ProofOfPossession, version: OpenId4VCIVersion): ProofOfPossessionBuilder<DIDDoc> {
     return new ProofOfPossessionBuilder({ proof, version });
   }
 
+  withAud(aud: string | string[]): this {
+    this.aud = aud;
+    return this;
+  }
+
   withClientId(clientId: string): this {
     this.clientId = clientId;
     return this;
@@ -113,7 +142,7 @@ export class ProofOfPossessionBuilder<DIDDoc> {
   }
 
   withTyp(typ: Typ): this {
-    if (this.version >= OpenId4VCIVersion.VER_1_0_11) {
+    if (this.mode === 'pop' && this.version >= OpenId4VCIVersion.VER_1_0_11) {
       if (!!typ && typ !== 'openid4vci-proof+jwt') {
         throw Error('typ must be openid4vci-proof+jwt for version 1.0.11 and up');
       }
@@ -160,7 +189,7 @@ export class ProofOfPossessionBuilder<DIDDoc> {
     if (jwt.header.typ) {
       this.withTyp(jwt.header.typ as Typ);
     }
-    if (this.version >= OpenId4VCIVersion.VER_1_0_11) {
+    if (!this.typ && this.version >= OpenId4VCIVersion.VER_1_0_11) {
       this.withTyp('openid4vci-proof+jwt');
     }
     this.withAlg(jwt.header.alg);
@@ -171,8 +200,8 @@ export class ProofOfPossessionBuilder<DIDDoc> {
     }
 
     if (jwt.payload) {
-      if (jwt.payload.iss) this.withClientId(jwt.payload.iss);
-      if (jwt.payload.aud) this.withIssuer(jwt.payload.aud);
+      if (jwt.payload.iss) this.mode === 'pop' ? this.withClientId(jwt.payload.iss) : this.withIssuer(jwt.payload.iss);
+      if (jwt.payload.aud) this.mode === 'pop' ? this.withIssuer(jwt.payload.aud) : this.withAud(jwt.payload.aud);
       if (jwt.payload.jti) this.withJti(jwt.payload.jti);
       if (jwt.payload.nonce) this.withAccessTokenNonce(jwt.payload.nonce);
     }
@@ -184,16 +213,18 @@ export class ProofOfPossessionBuilder<DIDDoc> {
       return Promise.resolve(this.proof);
     } else if (this.callbacks) {
       return await createProofOfPossession(
+        this.mode,
         this.callbacks,
         {
-          typ: this.typ ?? (this.version < OpenId4VCIVersion.VER_1_0_11 ? 'jwt' : 'openid4vci-proof+jwt'),
+          typ: this.typ ?? (this.version < OpenId4VCIVersion.VER_1_0_11 || this.mode === 'jwt' ? 'jwt' : 'openid4vci-proof+jwt'),
           kid: this.kid,
           jwk: this.jwk,
           jti: this.jti,
           alg: this.alg,
+          aud: this.aud,
           issuer: this.issuer,
           clientId: this.clientId,
-          nonce: this.cNonce,
+          ...(this.cNonce && { nonce: this.cNonce }),
         },
         this.jwt,
       );

package/lib/__tests__/CredentialRequestClientV1_0_11.spec.ts

@@ -16,7 +16,7 @@ import * as jose from 'jose';
 // @ts-ignore
 import nock from 'nock';
 
-import { CredentialOfferClientV1_0_11, CredentialRequestClientBuilderV1_0_11, MetadataClient, ProofOfPossessionBuilder } from '..';
+import { CredentialOfferClientV1_0_11, CredentialRequestClientBuilderV1_0_11, MetadataClientV1_0_13, ProofOfPossessionBuilder } from '..';
 
 import {
   IDENTIPROOF_ISSUER_URL,
@@ -177,7 +177,7 @@ describe('Credential Request Client with Walt.id ', () => {
     const credentialOffer = await CredentialOfferClientV1_0_11.fromURI(WALT_IRR_URI);
 
     const request = credentialOffer.credential_offer;
-    const metadata = await MetadataClient.retrieveAllMetadata(getIssuerFromCredentialOfferPayload(request) as string);
+    const metadata = await MetadataClientV1_0_13.retrieveAllMetadata(getIssuerFromCredentialOfferPayload(request) as string);
     expect(metadata.credential_endpoint).toEqual(WALT_OID4VCI_METADATA.credential_endpoint);
     expect(metadata.token_endpoint).toEqual(WALT_OID4VCI_METADATA.token_endpoint);
 

package/lib/__tests__/MetadataClient.spec.ts

@@ -22,7 +22,7 @@ import {
 import { getMockData } from './data/VciDataFixtures';
 
 //todo: skipping this. it was written for pre v13 version and we have to do some modifications to make it work
-describe.skip('MetadataClient with IdentiProof Issuer should', () => {
+describe('MetadataClient with IdentiProof Issuer should', () => {
   beforeAll(() => {
     nock.cleanAll();
   });
@@ -99,8 +99,7 @@ describe.skip('MetadataClient with IdentiProof Issuer should', () => {
     );
   });
 
-  // skipping because this metadata is for an older version. update it with a new metadata
-  it.skip('Fail if there is no credential endpoint with errors enabled', async () => {
+  it('Fail if there is no credential endpoint with errors enabled', async () => {
     const meta = JSON.parse(JSON.stringify(IDENTIPROOF_OID4VCI_METADATA));
     delete meta.credential_endpoint;
     nock(IDENTIPROOF_ISSUER_URL).get(WellKnownEndpoints.OPENID4VCI_ISSUER).reply(200, JSON.stringify(meta));
@@ -112,7 +111,7 @@ describe.skip('MetadataClient with IdentiProof Issuer should', () => {
     );
   });
 
-  it.skip('Succeed with default value if there is no credential endpoint with errors disabled', async () => {
+  it('Succeed with default value if there is no credential endpoint with errors disabled', async () => {
     nock(IDENTIPROOF_ISSUER_URL).get(WellKnownEndpoints.OPENID4VCI_ISSUER).reply(200, JSON.stringify(IDENTIPROOF_OID4VCI_METADATA));
     nock(IDENTIPROOF_AS_URL).get(WellKnownEndpoints.OAUTH_AS).reply(200, JSON.stringify(IDENTIPROOF_AS_METADATA));
     nock(IDENTIPROOF_AS_URL).get(WellKnownEndpoints.OPENID_CONFIGURATION).reply(404);

package/lib/__tests__/MetadataMocks.ts

@@ -48,6 +48,7 @@ export const INITIATION_TEST: CredentialOfferRequestWithBaseUrl = {
   scheme: 'openid-credential-offer',
   supportedFlows: [AuthzFlowType.PRE_AUTHORIZED_CODE_FLOW],
   version: 1013,
+  userPinRequired: true, // Determined from above tx_code
 };
 export const INITIATION_TEST_V1_0_08: CredentialOfferRequestWithBaseUrl = {
   baseUrl: 'openid-initiate-issuance://',

package/lib/__tests__/OpenID4VCIClient.spec.ts

@@ -1,8 +1,16 @@
-import { CodeChallengeMethod, WellKnownEndpoints } from '@sphereon/oid4vci-common';
+import {
+  CodeChallengeMethod,
+  CredentialOfferPayloadV1_0_13,
+  determineSpecVersionFromOffer,
+  determineSpecVersionFromURI,
+  OpenId4VCIVersion,
+  WellKnownEndpoints,
+} from '@sphereon/oid4vci-common';
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import nock from 'nock';
 
+import { createCredentialOfferURIFromObject } from '../../../issuer/lib';
 import { OpenID4VCIClient } from '../OpenID4VCIClient';
 
 const MOCK_URL = 'https://server.example.com/';
@@ -203,23 +211,48 @@ describe('OpenID4VCIClient should', () => {
   });
 });
 describe('should successfully handle isEbsi function', () => {
-  it.skip('should return true when calling isEbsi function', async () => {
+  it('should return true when calling isEbsi function', async () => {
+    nock(MOCK_URL).get(/.*/).reply(200, {});
+    nock(MOCK_URL).get(WellKnownEndpoints.OAUTH_AS).reply(404, {});
+    nock(MOCK_URL).get(WellKnownEndpoints.OPENID_CONFIGURATION).reply(404, {});
     const client = await OpenID4VCIClient.fromURI({
       clientId: 'test-client',
-      uri: 'openid-credential-offer://?credential_offer=%7B%22credential_issuer%22%3A%22https%3A%2F%2Fserver.example.com%22%2C%22credential_configuration_ids%22%3A%5B%22TestCredential%22%5D%7D',
+      uri: 'openid-credential-offer://?credential_offer=%7B%22credential_issuer%22%3A%22https%3A%2F%2Fserver.example.com%22%2C%20%22credentials%22%3A%5B%7B%22format%22%3A%22jwt_vc%22%2C%22types%22%3A%5B%22VerifiableCredential%22%2C%22VerifiableAttestation%22%2C%22CTWalletSameAuthorisedInTime%22%5D%2C%22trust_framework%22%3A%7B%22name%22%3A%22ebsi%22%2C%22type%22%3A%22Accreditation%22%2C%22uri%22%3A%22TIR%20link%20towards%20accreditation%22%7D%7D%5D%7D',
       createAuthorizationRequestURL: false,
     });
-    nock(MOCK_URL).get(/.*/).reply(200, {});
-    nock(MOCK_URL).get(WellKnownEndpoints.OAUTH_AS).reply(404, {});
-    nock(MOCK_URL).get(WellKnownEndpoints.OPENID_CONFIGURATION).reply(404, {});
 
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
-    client._state.endpointMetadata?.credentialIssuerMetadata?.credential_configurations_supported['TestCredential'] = {
-      trust_framework: {
-        name: 'ebsi_trust',
+    client._state.endpointMetadata?.credentialIssuerMetadata = {
+      credentials_supported: {
+        TestCredential: {
+          trust_framework: {
+            name: 'ebsi_trust',
+          },
+        },
       },
     };
     expect(client.isEBSI()).toBe(true);
   });
 });
+
+it('determine to be version 13', async () => {
+  const offer = {
+    grants: {
+      'urn:ietf:params:oauth:grant-type:pre-authorized_code': {
+        'pre-authorized_code': 'random',
+      },
+    },
+    credential_configuration_ids: ['Omzetbelasting'],
+    credential_issuer: 'https://example.com',
+  } satisfies CredentialOfferPayloadV1_0_13;
+  const offerUri = createCredentialOfferURIFromObject({ credential_offer: offer });
+
+  expect(determineSpecVersionFromOffer(offer)).toEqual(OpenId4VCIVersion.VER_1_0_13);
+  expect(determineSpecVersionFromURI(offerUri)).toEqual(OpenId4VCIVersion.VER_1_0_13);
+});
+it('determine to be version 11', async () => {
+  const offerUri =
+    'openid-credential-offer://?credential_offer=%7B%22grants%22%3A%7B%22urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Apre-authorized_code%22%3A%7B%22pre-authorized_code%22%3A%22wN39X8fU4FCU2MaykNRkCr%22%2C%22user_pin_required%22%3Afalse%7D%7D%2C%22credentials%22%3A%5B%22dbc2023%22%5D%2C%22credential_issuer%22%3A%22https%3A%2F%2Fssi.dutchblockchaincoalition.org%2Fagent%22%7D';
+  expect(determineSpecVersionFromURI(offerUri)).toEqual(OpenId4VCIVersion.VER_1_0_11);
+});

package/lib/__tests__/OpenID4VCIClientV1_0_11.spec.ts

@@ -200,3 +200,27 @@ describe('OpenID4VCIClientV1_0_11 should', () => {
     );
   });
 });
+
+it('should return true when calling isEbsi function', async () => {
+  nock(MOCK_URL).get(/.*/).reply(200, {});
+  nock(MOCK_URL).get(WellKnownEndpoints.OAUTH_AS).reply(404, {});
+  nock(MOCK_URL).get(WellKnownEndpoints.OPENID_CONFIGURATION).reply(404, {});
+  const client = await OpenID4VCIClientV1_0_11.fromURI({
+    clientId: 'test-client',
+    uri: 'openid-credential-offer://?credential_offer=%7B%22credential_issuer%22%3A%22https%3A%2F%2Fserver.example.com%22%2C%20%22credentials%22%3A%5B%7B%22format%22%3A%22jwt_vc%22%2C%22types%22%3A%5B%22VerifiableCredential%22%2C%22VerifiableAttestation%22%2C%22CTWalletSameAuthorisedInTime%22%5D%2C%22trust_framework%22%3A%7B%22name%22%3A%22ebsi%22%2C%22type%22%3A%22Accreditation%22%2C%22uri%22%3A%22TIR%20link%20towards%20accreditation%22%7D%7D%5D%7D',
+    createAuthorizationRequestURL: false,
+  });
+
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  client._state.endpointMetadata?.credentialIssuerMetadata = {
+    credentials_supported: {
+      TestCredential: {
+        trust_framework: {
+          name: 'ebsi_trust',
+        },
+      },
+    },
+  };
+  expect(client.isEBSI()).toBe(true);
+});

package/lib/__tests__/OpenID4VCIClientV1_0_13.spec.ts

@@ -0,0 +1,204 @@
+import { CodeChallengeMethod, WellKnownEndpoints } from '@sphereon/oid4vci-common';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import nock from 'nock';
+
+import { OpenID4VCIClientV1_0_13 } from '../OpenID4VCIClientV1_0_13';
+
+const MOCK_URL = 'https://server.example.com/';
+
+describe('OpenID4VCIClientV1_0_13 should', () => {
+  let client: OpenID4VCIClientV1_0_13;
+
+  beforeEach(async () => {
+    nock(MOCK_URL).get(/.*/).reply(200, {});
+    nock(MOCK_URL).get(WellKnownEndpoints.OAUTH_AS).reply(404, {});
+    nock(MOCK_URL).get(WellKnownEndpoints.OPENID_CONFIGURATION).reply(404, {});
+    client = await OpenID4VCIClientV1_0_13.fromURI({
+      clientId: 'test-client',
+      uri: 'openid-credential-offer://?credential_offer=%7B%22credential_issuer%22%3A%22https%3A%2F%2Fserver.example.com%22%2C%22credential_configuration_ids%22%3A%5B%22TestCredential%22%5D%7D',
+      createAuthorizationRequestURL: false,
+    });
+  });
+
+  afterEach(() => {
+    nock.cleanAll();
+  });
+
+  it('should successfully construct an authorization request url', async () => {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    client._state.endpointMetadata?.credentialIssuerMetadata.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
+    const url = await client.createAuthorizationRequestUrl({
+      authorizationRequest: {
+        scope: 'openid TestCredential',
+        redirectUri: 'http://localhost:8881/cb',
+      },
+    });
+
+    const urlSearchParams = new URLSearchParams(url.split('?')[1]);
+    const scope = urlSearchParams.get('scope')?.split(' ');
+
+    expect(scope?.[0]).toBe('openid');
+  });
+  it('throw an error if authorization endpoint is not set in server metadata', async () => {
+    await expect(
+      client.createAuthorizationRequestUrl({
+        authorizationRequest: {
+          scope: 'openid TestCredential',
+          redirectUri: 'http://localhost:8881/cb',
+        },
+      }),
+    ).rejects.toThrow(Error('Server metadata does not contain authorization endpoint'));
+  });
+  it("injects 'openid' as the first scope if not provided", async () => {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    client._state.endpointMetadata?.credentialIssuerMetadata.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
+
+    const url = await client.createAuthorizationRequestUrl({
+      pkce: {
+        codeChallengeMethod: CodeChallengeMethod.S256,
+        codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
+      },
+      authorizationRequest: {
+        scope: 'TestCredential',
+        redirectUri: 'http://localhost:8881/cb',
+      },
+    });
+
+    const urlSearchParams = new URLSearchParams(url.split('?')[1]);
+    const scope = urlSearchParams.get('scope')?.split(' ');
+
+    expect(scope?.[0]).toBe('openid');
+  });
+  it('throw an error if no scope and no authorization_details is provided', async () => {
+    nock(MOCK_URL).get(/.*/).reply(200, {});
+    nock(MOCK_URL).get(WellKnownEndpoints.OAUTH_AS).reply(200, {});
+    nock(MOCK_URL).get(WellKnownEndpoints.OPENID_CONFIGURATION).reply(200, {});
+    // Use a client with issuer only to trigger the error
+    client = await OpenID4VCIClientV1_0_13.fromCredentialIssuer({
+      credentialIssuer: MOCK_URL,
+      createAuthorizationRequestURL: false,
+      retrieveServerMetadata: false,
+    });
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    client._state.endpointMetadata = {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      credentialIssuerMetadata: {
+        authorization_endpoint: `${MOCK_URL}v1/auth/authorize`,
+        token_endpoint: `${MOCK_URL}/token`,
+      },
+    };
+    // client._state.endpointMetadata.credentialIssuerMetadata.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
+
+    await expect(
+      client.createAuthorizationRequestUrl({
+        pkce: {
+          codeChallengeMethod: CodeChallengeMethod.S256,
+          codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
+        },
+        authorizationRequest: {
+          clientId: 'clientId',
+          redirectUri: 'http://localhost:8881/cb',
+        },
+      }),
+    ).rejects.toThrow(Error('Please provide a scope or authorization_details if no credential offer is present'));
+  });
+  it('create an authorization request url with authorization_details array property', async () => {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    client._state.endpointMetadata?.credentialIssuerMetadata.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
+
+    await expect(
+      client.createAuthorizationRequestUrl({
+        pkce: {
+          codeChallengeMethod: CodeChallengeMethod.S256,
+          codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
+        },
+        authorizationRequest: {
+          authorizationDetails: [
+            {
+              type: 'openid_credential',
+              format: 'ldp_vc',
+              credential_definition: {
+                '@context': ['https://www.w3.org/2018/credentials/v1', 'https://www.w3.org/2018/credentials/examples/v1'],
+                types: ['VerifiableCredential', 'UniversityDegreeCredential'],
+              },
+            },
+            {
+              type: 'openid_credential',
+              // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+              // @ts-ignore
+              format: 'mso_mdoc',
+              doctype: 'org.iso.18013.5.1.mDL',
+            },
+          ],
+          redirectUri: 'http://localhost:8881/cb',
+        },
+      }),
+    ).resolves.toEqual(
+      'https://server.example.com/v1/auth/authorize?response_type=code&code_challenge_method=S256&code_challenge=mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs&authorization_details=%5B%7B%22type%22%3A%22openid_credential%22%2C%22format%22%3A%22ldp_vc%22%2C%22credential_definition%22%3A%7B%22%40context%22%3A%5B%22https%3A%2F%2Fwww%2Ew3%2Eorg%2F2018%2Fcredentials%2Fv1%22%2C%22https%3A%2F%2Fwww%2Ew3%2Eorg%2F2018%2Fcredentials%2Fexamples%2Fv1%22%5D%2C%22types%22%3A%5B%22VerifiableCredential%22%2C%22UniversityDegreeCredential%22%5D%7D%2C%22locations%22%3A%5B%22https%3A%2F%2Fserver%2Eexample%2Ecom%22%5D%7D%2C%7B%22type%22%3A%22openid_credential%22%2C%22format%22%3A%22mso_mdoc%22%2C%22doctype%22%3A%22org%2Eiso%2E18013%2E5%2E1%2EmDL%22%2C%22locations%22%3A%5B%22https%3A%2F%2Fserver%2Eexample%2Ecom%22%5D%7D%5D&redirect_uri=http%3A%2F%2Flocalhost%3A8881%2Fcb&client_id=test-client&scope=openid',
+    );
+  });
+  it('create an authorization request url with authorization_details object property', async () => {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    client._state.endpointMetadata?.credentialIssuerMetadata.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
+
+    await expect(
+      client.createAuthorizationRequestUrl({
+        pkce: {
+          codeChallengeMethod: CodeChallengeMethod.S256,
+          codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
+        },
+        authorizationRequest: {
+          authorizationDetails: {
+            type: 'openid_credential',
+            format: 'ldp_vc',
+            credential_definition: {
+              '@context': ['https://www.w3.org/2018/credentials/v1', 'https://www.w3.org/2018/credentials/examples/v1'],
+              types: ['VerifiableCredential', 'UniversityDegreeCredential'],
+            },
+          },
+          redirectUri: 'http://localhost:8881/cb',
+        },
+      }),
+    ).resolves.toEqual(
+      'https://server.example.com/v1/auth/authorize?response_type=code&code_challenge_method=S256&code_challenge=mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs&authorization_details=%7B%22type%22%3A%22openid_credential%22%2C%22format%22%3A%22ldp_vc%22%2C%22credential_definition%22%3A%7B%22%40context%22%3A%5B%22https%3A%2F%2Fwww%2Ew3%2Eorg%2F2018%2Fcredentials%2Fv1%22%2C%22https%3A%2F%2Fwww%2Ew3%2Eorg%2F2018%2Fcredentials%2Fexamples%2Fv1%22%5D%2C%22types%22%3A%5B%22VerifiableCredential%22%2C%22UniversityDegreeCredential%22%5D%7D%2C%22locations%22%3A%5B%22https%3A%2F%2Fserver%2Eexample%2Ecom%22%5D%7D&redirect_uri=http%3A%2F%2Flocalhost%3A8881%2Fcb&client_id=test-client&scope=openid',
+    );
+  });
+
+  it('create an authorization request url with authorization_details and scope', async () => {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    client._state.endpointMetadata.credentialIssuerMetadata.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
+
+    await expect(
+      client.createAuthorizationRequestUrl({
+        pkce: {
+          codeChallengeMethod: CodeChallengeMethod.S256,
+          codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
+        },
+        authorizationRequest: {
+          authorizationDetails: {
+            type: 'openid_credential',
+            format: 'ldp_vc',
+            locations: ['https://test.com'],
+            credential_definition: {
+              '@context': ['https://www.w3.org/2018/credentials/v1', 'https://www.w3.org/2018/credentials/examples/v1'],
+              types: ['VerifiableCredential', 'UniversityDegreeCredential'],
+            },
+          },
+          scope: 'openid',
+          redirectUri: 'http://localhost:8881/cb',
+        },
+      }),
+    ).resolves.toEqual(
+      'https://server.example.com/v1/auth/authorize?response_type=code&code_challenge_method=S256&code_challenge=mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs&authorization_details=%7B%22type%22%3A%22openid_credential%22%2C%22format%22%3A%22ldp_vc%22%2C%22locations%22%3A%5B%22https%3A%2F%2Ftest%2Ecom%22%2C%22https%3A%2F%2Fserver%2Eexample%2Ecom%22%5D%2C%22credential_definition%22%3A%7B%22%40context%22%3A%5B%22https%3A%2F%2Fwww%2Ew3%2Eorg%2F2018%2Fcredentials%2Fv1%22%2C%22https%3A%2F%2Fwww%2Ew3%2Eorg%2F2018%2Fcredentials%2Fexamples%2Fv1%22%5D%2C%22types%22%3A%5B%22VerifiableCredential%22%2C%22UniversityDegreeCredential%22%5D%7D%7D&redirect_uri=http%3A%2F%2Flocalhost%3A8881%2Fcb&client_id=test-client&scope=openid',
+    );
+  });
+});

package/lib/__tests__/SdJwt.spec.ts

@@ -8,7 +8,7 @@ import {
 // @ts-ignore
 import nock from 'nock';
 
-import { OpenID4VCIClient } from '..';
+import { OpenID4VCIClientV1_0_13 } from '..';
 import { createAccessTokenResponse, IssuerMetadataBuilderV1_13, VcIssuerBuilder } from '../../../issuer';
 
 export const UNIT_TEST_TIMEOUT = 30000;
@@ -88,7 +88,7 @@ describe('sd-jwt vc', () => {
         'openid-credential-offer://?credential_offer=%7B%22grants%22%3A%7B%22urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Apre-authorized_code%22%3A%7B%22pre-authorized_code%22%3A%22123%22%2C%22tx_code%22%3A%7B%22input_mode%22%3A%22text%22%2C%22length%22%3A3%7D%7D%7D%2C%22credential_configuration_ids%22%3A%5B%22SdJwtCredential%22%5D%2C%22credential_issuer%22%3A%22https%3A%2F%2Fexample.com%22%7D',
       );
 
-      const client = await OpenID4VCIClient.fromURI({
+      const client = await OpenID4VCIClientV1_0_13.fromURI({
         uri: offerUri.uri,
       });
 

package/lib/__tests__/SphereonE2E.spec.test.ts

@@ -25,7 +25,8 @@ const jwk: JWK = {
 // priv hex: 913466d1a38d1d8c0d3c0fb0fc3b633075085a31372bbd2a8022215a88d9d1e5
 const did = `did:key:z6Mki5ZwZKN1dBQprfJTikUvkDxrHijiiQngkWviMF5gw2Hv`;
 const kid = `${did}#z6Mki5ZwZKN1dBQprfJTikUvkDxrHijiiQngkWviMF5gw2Hv`;
-describe('OID4VCI-Client using Sphereon issuer should', () => {
+// Sphereon infra down rn
+describe.skip('OID4VCI-Client using Sphereon issuer should', () => {
   async function test(format: 'ldp_vc' | 'jwt_vc_json') {
     debug.enable('*');
     const offer = await getCredentialOffer(format);
@@ -59,14 +60,14 @@ describe('OID4VCI-Client using Sphereon issuer should', () => {
     expect(format.startsWith(wrappedVC.format)).toEqual(true);
   }
 
-  xit(
+  it(
     'succeed in a full flow with the client using OpenID4VCI version 11 and ldp_vc',
     async () => {
       await test('ldp_vc');
     },
     UNIT_TEST_TIMEOUT,
   );
-  xit(
+  it(
     'succeed in a full flow with the client using OpenID4VCI version 11 and jwt_vc_json',
     async () => {
       await test('jwt_vc_json');

package/lib/index.ts

@@ -1,3 +1,8 @@
+import { VCI_LOGGERS } from '@sphereon/oid4vci-common';
+import { ISimpleLogger } from '@sphereon/ssi-types';
+
+export const LOG: ISimpleLogger<string> = VCI_LOGGERS.get('sphereon:oid4vci:client');
+
 export * from './AccessTokenClient';
 export * from './AccessTokenClientV1_0_11';
 export * from './AuthorizationCodeClient';
@@ -5,12 +10,15 @@ export * from './AuthorizationCodeClientV1_0_11';
 export * from './CredentialRequestClient';
 export * from './CredentialOfferClient';
 export * from './CredentialOfferClientV1_0_11';
+export * from './CredentialOfferClientV1_0_13';
 export * from './CredentialRequestClientV1_0_11';
 export * from './CredentialRequestClientBuilder';
 export * from './CredentialRequestClientBuilderV1_0_11';
 export * from './functions';
 export * from './MetadataClient';
+export * from './MetadataClientV1_0_13';
 export * from './MetadataClientV1_0_11';
 export * from './OpenID4VCIClient';
+export * from './OpenID4VCIClientV1_0_13';
 export * from './OpenID4VCIClientV1_0_11';
 export * from './ProofOfPossessionBuilder';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sphereon/oid4vci-client",
-  "version": "0.10.4-unstable.98+b0ade3b",
+  "version": "0.12.0",
   "description": "OpenID for Verifiable Credential Issuance (OpenID4VCI) client",
   "source": "lib/index.ts",
   "main": "dist/index.js",
@@ -15,8 +15,8 @@
     "build": "tsc"
   },
   "dependencies": {
-    "@sphereon/oid4vci-common": "0.10.4-unstable.98+b0ade3b",
-    "@sphereon/ssi-types": "0.24.1-unstable.129",
+    "@sphereon/oid4vci-common": "0.12.0",
+    "@sphereon/ssi-types": "0.25.1-unstable.87",
     "cross-fetch": "^3.1.8",
     "debug": "^4.3.4"
   },
@@ -69,5 +69,5 @@
     "OIDC4VCI",
     "OID4VCI"
   ],
-  "gitHead": "b0ade3b9482bc6be469b46e8ce886359e3ccdf82"
+  "gitHead": "a76c382a36e38428391c9e8d1a6b67e477fc659a"
 }