@sphereon/oid4vci-client 0.8.2-next.48 → 0.8.2-next.87

package/lib/__tests__/AccessTokenClient.spec.ts

@@ -1,4 +1,6 @@
 import { AccessTokenRequest, AccessTokenResponse, GrantTypes, OpenIDResponse, WellKnownEndpoints } from '@sphereon/oid4vci-common';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
 import nock from 'nock';
 
 import { AccessTokenClient } from '../AccessTokenClient';

package/lib/__tests__/CredentialRequestClient.spec.ts

@@ -157,7 +157,7 @@ describe('Credential Request Client ', () => {
 });
 
 describe('Credential Request Client with Walt.id ', () => {
-  beforeAll(() => {
+  beforeEach(() => {
     nock.cleanAll();
   });
 
@@ -165,7 +165,7 @@ describe('Credential Request Client with Walt.id ', () => {
     nock.cleanAll();
   });
   it('should have correct metadata endpoints', async function () {
-    // nock.cleanAll();
+    nock.cleanAll();
     const WALT_IRR_URI =
       'openid-initiate-issuance://?issuer=https%3A%2F%2Fjff.walt.id%2Fissuer-api%2Foidc%2F&credential_type=OpenBadgeCredential&pre-authorized_code=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJhOTUyZjUxNi1jYWVmLTQ4YjMtODIxYy00OTRkYzgyNjljZjAiLCJwcmUtYXV0aG9yaXplZCI6dHJ1ZX0.YE5DlalcLC2ChGEg47CQDaN1gTxbaQqSclIVqsSAUHE&user_pin_required=false';
     const credentialOffer = await CredentialOfferClient.fromURI(WALT_IRR_URI);
@@ -184,6 +184,13 @@ describe('Credential Request Client with Walt.id ', () => {
 });
 
 describe('Credential Request Client with different issuers ', () => {
+  beforeEach(() => {
+    nock.cleanAll();
+  });
+
+  afterEach(() => {
+    nock.cleanAll();
+  });
   it('should create correct CredentialRequest for Spruce', async () => {
     const IRR_URI =
       'openid-initiate-issuance://?issuer=https%3A%2F%2Fngi%2Doidc4vci%2Dtest%2Espruceid%2Exyz&credential_type=OpenBadgeCredential&pre-authorized_code=eyJhbGciOiJFUzI1NiJ9.eyJjcmVkZW50aWFsX3R5cGUiOlsiT3BlbkJhZGdlQ3JlZGVudGlhbCJdLCJleHAiOiIyMDIzLTA0LTIwVDA5OjA0OjM2WiIsIm5vbmNlIjoibWFibmVpT0VSZVB3V3BuRFFweEt3UnRsVVRFRlhGUEwifQ.qOZRPN8sTv_knhp7WaWte2-aDULaPZX--2i9unF6QDQNUllqDhvxgIHMDCYHCV8O2_Gj-T2x1J84fDMajE3asg&user_pin_required=false';
@@ -208,6 +215,7 @@ describe('Credential Request Client with different issuers ', () => {
   });
 
   it('should create correct CredentialRequest for Walt', async () => {
+    nock.cleanAll();
     const IRR_URI =
       'openid-initiate-issuance://?issuer=https%3A%2F%2Fjff.walt.id%2Fissuer-api%2Fdefault%2Foidc%2F&credential_type=OpenBadgeCredential&pre-authorized_code=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIwMTc4OTNjYy04ZTY3LTQxNzItYWZlOS1lODcyYmYxNDBlNWMiLCJwcmUtYXV0aG9yaXplZCI6dHJ1ZX0.ODfq2AIhOcB61dAb3zMrXBJjPJaf53zkeHh_AssYyYA&user_pin_required=false';
     const credentialOffer = await (

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

@@ -1,4 +1,4 @@
-import { Alg, CodeChallengeMethod, Jwt } from '@sphereon/oid4vci-common';
+import { Alg, Jwt } from '@sphereon/oid4vci-common';
 import { toJwk } from '@sphereon/ssi-sdk-ext.key-utils';
 import { CredentialMapper } from '@sphereon/ssi-types';
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -52,7 +52,9 @@ const DID_URL_ENCODED =
 const kid = `${DID}#z2dmzD81cgPx8Vki7JbuuMmFYrWPgYoytykUZ3eyqht1j9Kbrm54tL4pRrDDhR1QJ5RHPMXUq5MzYpZL2k35vya5eMiNxschNy9AJ74CC3MmcYiZJGZfyhWQ6qDgTVcDSHdquwPYvLDut383JbrgYdZYYSC2merTMgmQtUi3huYhaky1qE`;
 
 // const jw = jose.importKey()
-describe('OID4VCI-Client using Sphereon issuer should', () => {
+
+// EBSI returning a 500 in credential endpoint all of a sudden
+describe.skip('OID4VCI-Client using Sphereon issuer should', () => {
   async function test(credentialType: 'CTWalletCrossPreAuthorisedInTime' | 'CTWalletCrossPreAuthorisedDeferred' | 'CTWalletCrossAuthorisedInTime') {
     debug.enable('*');
     const offer = await getCredentialOffer(credentialType);
@@ -68,10 +70,10 @@ describe('OID4VCI-Client using Sphereon issuer should', () => {
     expect(client.getAccessTokenEndpoint()).toEqual(`${AUTH_URL}/token`);
 
     if (credentialType !== 'CTWalletCrossPreAuthorisedInTime') {
-      const url = client.createAuthorizationRequestUrl({
-        redirectUri: 'openid4vc%3A',
-        codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
-        codeChallengeMethod: CodeChallengeMethod.SHA256,
+      const url = await client.createAuthorizationRequestUrl({
+        authorizationRequest: {
+          redirectUri: 'openid4vc%3A',
+        },
       });
       const result = await fetch(url);
       console.log(result.text());

package/lib/__tests__/OpenID4VCIClient.spec.ts

@@ -17,6 +17,7 @@ describe('OpenID4VCIClient should', () => {
     client = await OpenID4VCIClient.fromURI({
       clientId: 'test-client',
       uri: 'openid-initiate-issuance://?issuer=https://server.example.com&credential_type=TestCredential',
+      createAuthorizationRequestURL: false,
     });
   });
 
@@ -24,15 +25,15 @@ describe('OpenID4VCIClient should', () => {
     nock.cleanAll();
   });
 
-  it('should create successfully construct an authorization request url', async () => {
+  it('should successfully construct an authorization request url', async () => {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
-    client._endpointMetadata?.credentialIssuerMetadata.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
-    const url = client.createAuthorizationRequestUrl({
-      codeChallengeMethod: CodeChallengeMethod.SHA256,
-      codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
-      scope: 'openid TestCredential',
-      redirectUri: 'http://localhost:8881/cb',
+    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]);
@@ -41,25 +42,29 @@ describe('OpenID4VCIClient should', () => {
     expect(scope?.[0]).toBe('openid');
   });
   it('throw an error if authorization endpoint is not set in server metadata', async () => {
-    expect(() => {
+    await expect(
       client.createAuthorizationRequestUrl({
-        codeChallengeMethod: CodeChallengeMethod.SHA256,
-        codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
-        scope: 'openid TestCredential',
-        redirectUri: 'http://localhost:8881/cb',
-      });
-    }).toThrow(Error('Server metadata does not contain authorization endpoint'));
+        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._endpointMetadata?.credentialIssuerMetadata.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
+    client._state.endpointMetadata?.credentialIssuerMetadata.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
 
-    const url = client.createAuthorizationRequestUrl({
-      codeChallengeMethod: CodeChallengeMethod.SHA256,
-      codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
-      scope: 'TestCredential',
-      redirectUri: 'http://localhost:8881/cb',
+    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]);
@@ -69,98 +74,129 @@ describe('OpenID4VCIClient should', () => {
   });
   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(404, {});
-    nock(MOCK_URL).get(WellKnownEndpoints.OPENID_CONFIGURATION).reply(404, {});
+    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 OpenID4VCIClient.fromCredentialIssuer({ credentialIssuer: 'https://server.example.com' });
+    client = await OpenID4VCIClient.fromCredentialIssuer({
+      credentialIssuer: MOCK_URL,
+      createAuthorizationRequestURL: false,
+      retrieveServerMetadata: false,
+    });
+
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
-    client._endpointMetadata?.credentialIssuerMetadata.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
+    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`;
 
-    expect(() => {
+    await expect(
       client.createAuthorizationRequestUrl({
-        codeChallengeMethod: CodeChallengeMethod.SHA256,
-        codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
-        redirectUri: 'http://localhost:8881/cb',
-      });
-    }).toThrow(Error('Please provide a scope or authorization_details'));
+        pkce: {
+          codeChallengeMethod: CodeChallengeMethod.S256,
+          codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
+        },
+        authorizationRequest: {
+          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._endpointMetadata?.credentialIssuerMetadata.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
+    client._state.endpointMetadata?.credentialIssuerMetadata.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
 
-    expect(
+    await expect(
       client.createAuthorizationRequestUrl({
-        codeChallengeMethod: CodeChallengeMethod.SHA256,
-        codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
-        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'],
+        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',
-            format: 'mso_mdoc',
-            doctype: 'org.iso.18013.5.1.mDL',
-          },
-        ],
-        redirectUri: 'http://localhost:8881/cb',
+            {
+              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',
+        },
       }),
-    ).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%22https%3A%2F%2Fserver%2Eexample%2Ecom%22%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%22https%3A%2F%2Fserver%2Eexample%2Ecom%22%7D%5D&redirect_uri=http%3A%2F%2Flocalhost%3A8881%2Fcb&scope=openid&client_id=test-client',
+    ).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._endpointMetadata?.credentialIssuerMetadata.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
+    client._state.endpointMetadata?.credentialIssuerMetadata.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
 
-    expect(
+    await expect(
       client.createAuthorizationRequestUrl({
-        codeChallengeMethod: CodeChallengeMethod.SHA256,
-        codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
-        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'],
+        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',
         },
-        redirectUri: 'http://localhost:8881/cb',
       }),
-    ).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%22https%3A%2F%2Fserver%2Eexample%2Ecom%22%7D&redirect_uri=http%3A%2F%2Flocalhost%3A8881%2Fcb&scope=openid&client_id=test-client',
+    ).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._endpointMetadata.credentialIssuerMetadata.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
+    client._state.endpointMetadata.credentialIssuerMetadata.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
 
-    expect(
+    await expect(
       client.createAuthorizationRequestUrl({
-        codeChallengeMethod: CodeChallengeMethod.SHA256,
-        codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
-        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'],
+        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',
         },
-        scope: 'openid',
-        redirectUri: 'http://localhost:8881/cb',
       }),
-    ).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&scope=openid&client_id=test-client',
+    ).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__/OpenID4VCIClientPAR.spec.ts

@@ -1,4 +1,6 @@
-import { CodeChallengeMethod, WellKnownEndpoints } from '@sphereon/oid4vci-common';
+import { PARMode, WellKnownEndpoints } from '@sphereon/oid4vci-common';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
 import nock from 'nock';
 
 import { OpenID4VCIClient } from '../OpenID4VCIClient';
@@ -13,6 +15,7 @@ describe('OpenID4VCIClient', () => {
     nock(MOCK_URL).get(WellKnownEndpoints.OPENID_CONFIGURATION).reply(404, {});
     nock(`${MOCK_URL}`).post('/v1/auth/par').reply(201, { request_uri: 'test_uri', expires_in: 90 });
     client = await OpenID4VCIClient.fromURI({
+      createAuthorizationRequestURL: false,
       clientId: 'test-client',
       uri: 'openid-initiate-issuance://?issuer=https://server.example.com&credential_type=TestCredential',
     });
@@ -25,53 +28,58 @@ describe('OpenID4VCIClient', () => {
   it('should successfully retrieve the authorization code using PAR', async () => {
     client.endpointMetadata.credentialIssuerMetadata!.pushed_authorization_request_endpoint = `${MOCK_URL}v1/auth/par`;
     client.endpointMetadata.credentialIssuerMetadata!.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
-    const actual = await client.acquirePushedAuthorizationRequestURI({
-      codeChallengeMethod: CodeChallengeMethod.SHA256,
-      codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
-      scope: 'openid TestCredential',
-      redirectUri: 'http://localhost:8881/cb',
+    const actual = await client.createAuthorizationRequestUrl({
+      authorizationRequest: {
+        parMode: PARMode.REQUIRE,
+        scope: 'openid TestCredential',
+        redirectUri: 'http://localhost:8881/cb',
+      },
     });
     expect(actual).toEqual('https://server.example.com/v1/auth/authorize?request_uri=test_uri');
   });
 
   it('should fail when pushed_authorization_request_endpoint is not present', async () => {
+    client.endpointMetadata.credentialIssuerMetadata!.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
     await expect(() =>
-      client.acquirePushedAuthorizationRequestURI({
-        codeChallengeMethod: CodeChallengeMethod.SHA256,
-        codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
-        scope: 'openid TestCredential',
-        redirectUri: 'http://localhost:8881/cb',
+      client.createAuthorizationRequestUrl({
+        authorizationRequest: {
+          parMode: PARMode.REQUIRE,
+          scope: 'openid TestCredential',
+          redirectUri: 'http://localhost:8881/cb',
+        },
       }),
-    ).rejects.toThrow(Error('Server metadata does not contain pushed authorization request endpoint'));
+    ).rejects.toThrow(Error('PAR mode is set to required by Authorization Server does not support PAR!'));
   });
 
   it('should fail when authorization_details and scope are not present', async () => {
     await expect(() =>
-      client.acquirePushedAuthorizationRequestURI({
-        codeChallengeMethod: CodeChallengeMethod.SHA256,
-        codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
-        redirectUri: 'http://localhost:8881/cb',
+      client.createAuthorizationRequestUrl({
+        authorizationRequest: {
+          parMode: PARMode.REQUIRE,
+          redirectUri: 'http://localhost:8881/cb',
+        },
       }),
-    ).rejects.toThrow(Error('Please provide a scope or authorization_details'));
+    ).rejects.toThrow(Error('Could not create authorization details from credential offer. Please pass in explicit details'));
   });
 
   it('should not fail when only authorization_details is present', async () => {
     client.endpointMetadata.credentialIssuerMetadata!.pushed_authorization_request_endpoint = `${MOCK_URL}v1/auth/par`;
     client.endpointMetadata.credentialIssuerMetadata!.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
-    const actual = await client.acquirePushedAuthorizationRequestURI({
-      codeChallengeMethod: CodeChallengeMethod.SHA256,
-      codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
-      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'],
+    const actual = await client.createAuthorizationRequestUrl({
+      authorizationRequest: {
+        parMode: PARMode.REQUIRE,
+        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',
+        ],
+        redirectUri: 'http://localhost:8881/cb',
+      },
     });
     expect(actual).toEqual('https://server.example.com/v1/auth/authorize?request_uri=test_uri');
   });
@@ -79,11 +87,12 @@ describe('OpenID4VCIClient', () => {
   it('should not fail when only scope is present', async () => {
     client.endpointMetadata.credentialIssuerMetadata!.pushed_authorization_request_endpoint = `${MOCK_URL}v1/auth/par`;
     client.endpointMetadata.credentialIssuerMetadata!.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
-    const actual = await client.acquirePushedAuthorizationRequestURI({
-      codeChallengeMethod: CodeChallengeMethod.SHA256,
-      codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
-      scope: 'openid TestCredential',
-      redirectUri: 'http://localhost:8881/cb',
+    const actual = await client.createAuthorizationRequestUrl({
+      authorizationRequest: {
+        parMode: PARMode.REQUIRE,
+        scope: 'openid TestCredential',
+        redirectUri: 'http://localhost:8881/cb',
+      },
     });
     expect(actual).toEqual('https://server.example.com/v1/auth/authorize?request_uri=test_uri');
   });
@@ -91,21 +100,22 @@ describe('OpenID4VCIClient', () => {
   it('should not fail when both authorization_details and scope are present', async () => {
     client.endpointMetadata.credentialIssuerMetadata!.pushed_authorization_request_endpoint = `${MOCK_URL}v1/auth/par`;
     client.endpointMetadata.credentialIssuerMetadata!.authorization_endpoint = `${MOCK_URL}v1/auth/authorize`;
-    const actual = await client.acquirePushedAuthorizationRequestURI({
-      codeChallengeMethod: CodeChallengeMethod.SHA256,
-      codeChallenge: 'mE2kPHmIprOqtkaYmESWj35yz-PB5vzdiSu0tAZ8sqs',
-      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'],
+    const actual = await client.createAuthorizationRequestUrl({
+      authorizationRequest: {
+        parMode: PARMode.REQUIRE,
+        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'],
+            },
           },
-        },
-      ],
-      scope: 'openid TestCredential',
-      redirectUri: 'http://localhost:8881/cb',
+        ],
+        scope: 'openid TestCredential',
+        redirectUri: 'http://localhost:8881/cb',
+      },
     });
     expect(actual).toEqual('https://server.example.com/v1/auth/authorize?request_uri=test_uri');
   });

package/lib/__tests__/SdJwt.spec.ts

@@ -1,4 +1,6 @@
 import { AccessTokenRequest, CredentialRequestV1_0_11, CredentialSupportedSdJwtVc } from '@sphereon/oid4vci-common';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
 import nock from 'nock';
 
 import { OpenID4VCIClient } from '..';

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

@@ -10,7 +10,7 @@ import { v4 } from 'uuid';
 
 import { OpenID4VCIClient } from '..';
 
-export const UNIT_TEST_TIMEOUT = 30000;
+export const UNIT_TEST_TIMEOUT = 60000;
 
 const ISSUER_URL = 'https://ssi.sphereon.com/pf3';
 
@@ -66,7 +66,7 @@ describe('OID4VCI-Client using Sphereon issuer should', () => {
     },
     UNIT_TEST_TIMEOUT,
   );
-  it(
+  xit(
     'succeed in a full flow with the client using OpenID4VCI version 11 and jwt_vc_json',
     async () => {
       await test('jwt_vc_json');

package/lib/functions/AuthorizationUtil.ts

@@ -0,0 +1,18 @@
+import { assertValidCodeVerifier, CodeChallengeMethod, createCodeChallenge, generateCodeVerifier, PKCEOpts } from '@sphereon/oid4vci-common';
+
+export const generateMissingPKCEOpts = (pkce: PKCEOpts) => {
+  if (pkce.disabled) {
+    return pkce;
+  }
+  if (!pkce.codeChallengeMethod) {
+    pkce.codeChallengeMethod = CodeChallengeMethod.S256;
+  }
+  if (!pkce.codeVerifier) {
+    pkce.codeVerifier = generateCodeVerifier();
+  }
+  assertValidCodeVerifier(pkce.codeVerifier);
+  if (!pkce.codeChallenge) {
+    pkce.codeChallenge = createCodeChallenge(pkce.codeVerifier, pkce.codeChallengeMethod);
+  }
+  return pkce;
+};

package/lib/index.ts

@@ -1,4 +1,5 @@
 export * from './AccessTokenClient';
+export * from './CredentialRequestClient';
 export * from './CredentialOfferClient';
 export * from './CredentialRequestClient';
 export * from './CredentialRequestClientBuilder';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sphereon/oid4vci-client",
-  "version": "0.8.2-next.48+81adb47",
+  "version": "0.8.2-next.87+9f0679e",
   "description": "OpenID for Verifiable Credential Issuance (OpenID4VCI) client",
   "source": "lib/index.ts",
   "main": "dist/index.js",
@@ -15,7 +15,7 @@
     "build": "tsc"
   },
   "dependencies": {
-    "@sphereon/oid4vci-common": "0.8.2-next.48+81adb47",
+    "@sphereon/oid4vci-common": "0.8.2-next.87+9f0679e",
     "@sphereon/ssi-types": "^0.18.1",
     "cross-fetch": "^3.1.8",
     "debug": "^4.3.4"
@@ -69,5 +69,5 @@
     "OIDC4VCI",
     "OID4VCI"
   ],
-  "gitHead": "81adb47112f687715737f17c5e8518739b8a6a58"
+  "gitHead": "9f0679e6cbf0b0ba7f7d4f8ecc2263981d4ef80e"
 }