@sphereon/oid4vci-client 0.2.0 → 0.4.1-next.285

package/lib/__tests__/AccessTokenClient.spec.ts

@@ -0,0 +1,225 @@
+import { AccessTokenRequest, AccessTokenRequestOpts, AccessTokenResponse, GrantTypes, OpenIDResponse } from '@sphereon/oid4vci-common';
+import nock from 'nock';
+
+import { AccessTokenClient } from '../AccessTokenClient';
+
+import { UNIT_TEST_TIMEOUT } from './IT.spec';
+import { INITIATION_TEST } from './MetadataMocks';
+
+const MOCK_URL = 'https://sphereonjunit20221013.com/';
+
+describe('AccessTokenClient should', () => {
+  beforeEach(() => {
+    nock.cleanAll();
+  });
+
+  afterEach(() => {
+    nock.cleanAll();
+  });
+
+  it(
+    'get Access Token for with pre-authorized code without resulting in errors',
+    async () => {
+      const accessTokenClient: AccessTokenClient = new AccessTokenClient();
+
+      const accessTokenRequest: AccessTokenRequest = {
+        grant_type: GrantTypes.PRE_AUTHORIZED_CODE,
+        'pre-authorized_code': '20221013',
+        client_id: 'sphereon',
+      } as AccessTokenRequest;
+
+      const body: AccessTokenResponse = {
+        access_token: 'ey6546.546654.64565',
+        authorization_pending: false,
+        c_nonce: 'c_nonce2022101300',
+        c_nonce_expires_in: 2022101300,
+        interval: 2022101300,
+        token_type: 'Bearer',
+      };
+      nock(MOCK_URL).post(/.*/).reply(200, JSON.stringify(body));
+
+      const accessTokenResponse: OpenIDResponse<AccessTokenResponse> = await accessTokenClient.acquireAccessTokenUsingRequest({
+        accessTokenRequest,
+        asOpts: { as: MOCK_URL },
+      });
+
+      expect(accessTokenResponse.successBody).toEqual(body);
+    },
+    UNIT_TEST_TIMEOUT
+  );
+
+  it(
+    'get Access Token for authorization code without resulting in errors',
+    async () => {
+      const accessTokenClient: AccessTokenClient = new AccessTokenClient();
+
+      const accessTokenRequest: AccessTokenRequest = {
+        client_id: 'test-client',
+        code_verifier: 'F0Y2OGARX2ppIERYdSVuLCV3Zi95Ci5yWzAYNU8QQC0',
+        code: '9mq3kwIuNZ88czRjJ2-UDxtaNXulOfxHSXo-kM01MLV',
+        redirect_uri: 'http://test.com/cb',
+        grant_type: GrantTypes.AUTHORIZATION_CODE,
+      } as AccessTokenRequest;
+
+      const body: AccessTokenResponse = {
+        access_token: '6W-kZopGNBq8e-5KvnGf2u0p0iGSxWZ7jIGV86nO1Dn',
+        expires_in: 3600,
+        scope: 'TestCredential',
+        token_type: 'Bearer',
+      };
+      nock(MOCK_URL).post(/.*/).reply(200, JSON.stringify(body));
+
+      const accessTokenResponse: OpenIDResponse<AccessTokenResponse> = await accessTokenClient.acquireAccessTokenUsingRequest({
+        accessTokenRequest,
+        asOpts: { as: MOCK_URL },
+      });
+
+      expect(accessTokenResponse.successBody).toEqual(body);
+    },
+    UNIT_TEST_TIMEOUT
+  );
+
+  it(
+    'get error for incorrect code',
+    async () => {
+      const accessTokenClient: AccessTokenClient = new AccessTokenClient();
+
+      const accessTokenRequest: AccessTokenRequest = {
+        grant_type: GrantTypes.PRE_AUTHORIZED_CODE,
+        'pre-authorized_code': '',
+        user_pin: '1.0',
+      } as AccessTokenRequest;
+
+      nock(MOCK_URL).post(/.*/).reply(200, {});
+
+      await expect(
+        accessTokenClient.acquireAccessTokenUsingRequest({
+          accessTokenRequest,
+          asOpts: { as: MOCK_URL },
+        })
+      ).rejects.toThrow('Pre-authorization must be proven by presenting the pre-authorized code. Code must be present.');
+    },
+    UNIT_TEST_TIMEOUT
+  );
+
+  it(
+    'get error for incorrect pin',
+    async () => {
+      const accessTokenClient: AccessTokenClient = new AccessTokenClient();
+
+      const accessTokenRequest: AccessTokenRequest = {
+        grant_type: GrantTypes.PRE_AUTHORIZED_CODE,
+        'pre-authorized_code': '20221013',
+      } as AccessTokenRequest;
+
+      nock(MOCK_URL).post(/.*/).reply(200, {});
+
+      await expect(
+        accessTokenClient.acquireAccessTokenUsingRequest({
+          accessTokenRequest,
+          isPinRequired: true,
+          asOpts: { as: MOCK_URL },
+        })
+      ).rejects.toThrow('A valid pin consisting of maximal 8 numeric characters must be present.');
+    },
+    UNIT_TEST_TIMEOUT
+  );
+
+  it(
+    'get error for incorrectly long pin',
+    async () => {
+      const accessTokenClient: AccessTokenClient = new AccessTokenClient();
+
+      const accessTokenRequest: AccessTokenRequest = {
+        grant_type: GrantTypes.PRE_AUTHORIZED_CODE,
+        'pre-authorized_code': '20221013',
+        client_id: 'sphereon.com',
+        user_pin: '123456789',
+      } as AccessTokenRequest;
+
+      nock(MOCK_URL).post(/.*/).reply(200, {});
+
+      await expect(
+        accessTokenClient.acquireAccessTokenUsingRequest({
+          accessTokenRequest,
+          isPinRequired: true,
+          asOpts: { as: MOCK_URL },
+        })
+      ).rejects.toThrow(Error('A valid pin consisting of maximal 8 numeric characters must be present.'));
+    },
+    UNIT_TEST_TIMEOUT
+  );
+
+  it(
+    'get success for correct length of pin',
+    async () => {
+      const accessTokenClient: AccessTokenClient = new AccessTokenClient();
+
+      const accessTokenRequest: AccessTokenRequest = {
+        grant_type: GrantTypes.PRE_AUTHORIZED_CODE,
+        'pre-authorized_code': '20221013',
+        client_id: 'sphereon.com',
+        user_pin: '12345678',
+      } as AccessTokenRequest;
+
+      const body: AccessTokenResponse = {
+        access_token: 'ey6546.546654.64565',
+        authorization_pending: false,
+        c_nonce: 'c_nonce2022101300',
+        c_nonce_expires_in: 2022101300,
+        interval: 2022101300,
+        token_type: 'Bearer',
+      };
+      nock(MOCK_URL).post(/.*/).reply(200, body);
+
+      const response = await accessTokenClient.acquireAccessTokenUsingRequest({
+        accessTokenRequest,
+        isPinRequired: true,
+        asOpts: { as: MOCK_URL },
+      });
+      expect(response.successBody).toEqual(body);
+    },
+    UNIT_TEST_TIMEOUT
+  );
+
+  it('get error for using a pin when not requested', async () => {
+    const accessTokenClient: AccessTokenClient = new AccessTokenClient();
+
+    nock(MOCK_URL).post(/.*/).reply(200, {});
+
+    await expect(() =>
+      accessTokenClient.acquireAccessToken({
+        credentialOffer: INITIATION_TEST,
+        pin: '1234',
+      })
+    ).rejects.toThrow(Error('Cannot set a pin, when the pin is not required.'));
+  });
+
+  it('get error if code_verifier is present when flow type is pre-authorized', async () => {
+    const accessTokenClient: AccessTokenClient = new AccessTokenClient();
+
+    nock(MOCK_URL).post(/.*/).reply(200, {});
+
+    const requestOpts: AccessTokenRequestOpts = {
+      credentialOffer: INITIATION_TEST,
+      pin: undefined,
+      codeVerifier: 'RylyWGQ-dzpObnEcoMBDIH9cTAwZXk1wYzktKxsOFgA',
+      code: 'LWCt225yj7gzT2cWeMP4hXj4B4oIYkEiGs4T6pfez91',
+      redirectUri: 'http://example.com/cb',
+    };
+
+    await expect(() => accessTokenClient.acquireAccessToken(requestOpts)).rejects.toThrow(
+      Error('Cannot pass a code_verifier when flow type is pre-authorized')
+    );
+  });
+
+  it('get error if no as, issuer and metadata values are present', async () => {
+    await expect(() =>
+      AccessTokenClient.determineTokenURL({
+        asOpts: undefined,
+        issuerOpts: undefined,
+        metadata: undefined,
+      })
+    ).toThrow(Error('Cannot determine token URL if no issuer, metadata and no Authorization Server values are present'));
+  });
+});

package/lib/__tests__/AuthorizationDetailsBuilder.spec.ts

@@ -0,0 +1,65 @@
+import { OID4VCICredentialFormat } from '@sphereon/oid4vci-common';
+
+import { AuthorizationDetailsBuilder } from '../AuthorizationDetailsBuilder';
+
+describe('AuthorizationDetailsBuilder test', () => {
+  it('should create AuthorizationDetails object from arrays', () => {
+    const actual = new AuthorizationDetailsBuilder()
+      .withFormats('jwt_vc' as OID4VCICredentialFormat)
+      .withLocations(['test1', 'test2'])
+      .withType('openid_credential')
+      .buildJwtVcJson();
+    expect(actual).toEqual({
+      type: 'openid_credential',
+      format: 'jwt_vc',
+      locations: ['test1', 'test2'],
+    });
+  });
+  it('should create AuthorizationDetails object from single objects', () => {
+    const actual = new AuthorizationDetailsBuilder()
+      .withFormats('jwt_vc' as OID4VCICredentialFormat)
+      .withLocations(['test1'])
+      .withType('openid_credential')
+      .buildJwtVcJson();
+    expect(actual).toEqual({
+      type: 'openid_credential',
+      format: 'jwt_vc',
+      locations: ['test1'],
+    });
+  });
+  it('should create AuthorizationDetails object if locations is missing', () => {
+    const actual = new AuthorizationDetailsBuilder()
+      .withFormats('jwt_vc' as OID4VCICredentialFormat)
+      .withType('openid_credential')
+      .buildJwtVcJson();
+    expect(actual).toEqual({
+      type: 'openid_credential',
+      format: 'jwt_vc',
+    });
+  });
+  it('should fail if type is missing', () => {
+    expect(() => {
+      new AuthorizationDetailsBuilder()
+        .withFormats('jwt_vc' as OID4VCICredentialFormat)
+        .withLocations(['test1'])
+        .buildJwtVcJson();
+    }).toThrow(Error('Type and format are required properties'));
+  });
+  it('should fail if format is missing', () => {
+    expect(() => {
+      new AuthorizationDetailsBuilder().withType('openid_credential').withLocations(['test1']).buildJwtVcJson();
+    }).toThrow(Error('Type and format are required properties'));
+  });
+  it('should be able to add random field to the object', () => {
+    const actual = new AuthorizationDetailsBuilder()
+      .withFormats('jwt_vc' as OID4VCICredentialFormat)
+      .withType('openid_credential')
+      .buildJwtVcJson();
+    actual['random'] = 'test';
+    expect(actual).toEqual({
+      type: 'openid_credential',
+      format: 'jwt_vc',
+      random: 'test',
+    });
+  });
+});

package/lib/__tests__/AuthzFlowType.spec.ts

@@ -0,0 +1,39 @@
+import { AuthzFlowType, CredentialOfferPayload } from '@sphereon/oid4vci-common';
+
+//todo: this file is just testing v9, we probably want to add v11 tests here as well
+describe('Authorization Flow Type determination', () => {
+  it('should return authorization code flow type with a single credential_type', () => {
+    expect(
+      AuthzFlowType.valueOf({
+        issuer: 'test',
+        credential_type: 'test',
+      } as CredentialOfferPayload)
+    ).toEqual(AuthzFlowType.AUTHORIZATION_CODE_FLOW);
+  });
+  it('should return authorization code flow type with a credential_type array', () => {
+    expect(
+      AuthzFlowType.valueOf({
+        issuer: 'test',
+        credential_type: ['test', 'test1'],
+      } as CredentialOfferPayload)
+    ).toEqual(AuthzFlowType.AUTHORIZATION_CODE_FLOW);
+  });
+  it('should return pre-authorized code flow with a single credential_type', () => {
+    expect(
+      AuthzFlowType.valueOf({
+        issuer: 'test',
+        credential_type: 'test',
+        'pre-authorized_code': 'test',
+      } as CredentialOfferPayload)
+    ).toEqual(AuthzFlowType.PRE_AUTHORIZED_CODE_FLOW);
+  });
+  it('should return pre-authorized code flow with a credential_type array', () => {
+    expect(
+      AuthzFlowType.valueOf({
+        issuer: 'test',
+        credential_type: ['test', 'test1'],
+        'pre-authorized_code': 'test',
+      } as CredentialOfferPayload)
+    ).toEqual(AuthzFlowType.PRE_AUTHORIZED_CODE_FLOW);
+  });
+});

package/lib/__tests__/CredentialRequestClient.spec.ts

@@ -0,0 +1,291 @@
+import { KeyObject } from 'crypto';
+
+import {
+  Alg,
+  EndpointMetadata,
+  getIssuerFromCredentialOfferPayload,
+  Jwt,
+  OpenId4VCIVersion,
+  ProofOfPossession,
+  URL_NOT_VALID,
+  WellKnownEndpoints,
+} from '@sphereon/oid4vci-common';
+import * as jose from 'jose';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import nock from 'nock';
+
+import { CredentialRequestClientBuilder, MetadataClient, ProofOfPossessionBuilder } from '..';
+import { CredentialOfferClient } from '../CredentialOfferClient';
+
+import { IDENTIPROOF_ISSUER_URL, IDENTIPROOF_OID4VCI_METADATA, INITIATION_TEST, WALT_OID4VCI_METADATA } from './MetadataMocks';
+import { getMockData } from './data/VciDataFixtures';
+
+const partialJWT = 'eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJkaWQ6ZXhhbXBsZTplYmZlYjFmN';
+
+const jwt: Jwt = {
+  header: { alg: Alg.ES256, kid: 'did:example:ebfeb1f712ebc6f1c276e12ec21/keys/1', typ: 'jwt' },
+  payload: { iss: 'sphereon:wallet', nonce: 'tZignsnFbp', jti: 'tZignsnFbp223', aud: IDENTIPROOF_ISSUER_URL },
+};
+
+const kid = 'did:example:ebfeb1f712ebc6f1c276e12ec21/keys/1';
+
+let keypair: KeyPair;
+
+async function proofOfPossessionCallbackFunction(args: Jwt, kid?: string): Promise<string> {
+  if (!args.payload.aud) {
+    throw Error('aud required');
+  } else if (!kid) {
+    throw Error('kid required');
+  }
+  return await new jose.SignJWT({ ...args.payload })
+    .setProtectedHeader({ alg: 'ES256' })
+    .setIssuedAt()
+    .setIssuer(kid)
+    .setAudience(args.payload.aud)
+    .setExpirationTime('2h')
+    .sign(keypair.privateKey);
+}
+
+interface KeyPair {
+  publicKey: KeyObject;
+  privateKey: KeyObject;
+}
+
+beforeAll(async () => {
+  const { privateKey, publicKey } = await jose.generateKeyPair('ES256');
+  keypair = { publicKey: publicKey as KeyObject, privateKey: privateKey as KeyObject };
+});
+
+beforeEach(async () => {
+  nock.cleanAll();
+  nock(IDENTIPROOF_ISSUER_URL).get(WellKnownEndpoints.OPENID4VCI_ISSUER).reply(200, JSON.stringify(IDENTIPROOF_OID4VCI_METADATA));
+});
+
+afterEach(async () => {
+  nock.cleanAll();
+});
+describe('Credential Request Client ', () => {
+  it('should get a failed credential response with an unsupported format', async function () {
+    const basePath = 'https://sphereonjunit2022101301.com/';
+    nock(basePath).post(/.*/).reply(500, {
+      error: 'unsupported_format',
+      error_description: 'This is a mock error message',
+    });
+
+    const credReqClient = CredentialRequestClientBuilder.fromCredentialOffer({ credentialOffer: INITIATION_TEST })
+      .withCredentialEndpoint(basePath + '/credential')
+      .withFormat('ldp_vc')
+      .withCredentialType('https://imsglobal.github.io/openbadges-specification/ob_v3p0.html#OpenBadgeCredential')
+      .build();
+    const proof: ProofOfPossession = await ProofOfPossessionBuilder.fromJwt({
+      jwt,
+      callbacks: {
+        signCallback: proofOfPossessionCallbackFunction,
+      },
+      version: OpenId4VCIVersion.VER_1_0_08,
+    })
+      // .withEndpointMetadata(metadata)
+      .withClientId('sphereon:wallet')
+      .withKid(kid)
+      .build();
+    expect(credReqClient.getCredentialEndpoint()).toEqual(basePath + '/credential');
+    const credentialRequest = await credReqClient.createCredentialRequest({ proofInput: proof, version: OpenId4VCIVersion.VER_1_0_08 });
+    expect(credentialRequest.proof?.jwt?.includes(partialJWT)).toBeTruthy();
+    const result = await credReqClient.acquireCredentialsUsingRequest(credentialRequest);
+    expect(result?.errorBody?.error).toBe('unsupported_format');
+  });
+
+  it('should get success credential response', async function () {
+    const mockedVC =
+      'eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJ2YyI6eyJAY29udGV4dCI6WyJodHRwczovL3d3dy53My5vcmcvMjAxOC9jcmVkZW50aWFscy92MSIsImh0dHBzOi8vd3d3LnczLm9yZy8yMDE4L2NyZWRlbnRpYWxzL2V4YW1wbGVzL3YxIl0sImlkIjoiaHR0cDovL2V4YW1wbGUuZWR1L2NyZWRlbnRpYWxzLzM3MzIiLCJ0eXBlIjpbIlZlcmlmaWFibGVDcmVkZW50aWFsIiwiVW5pdmVyc2l0eURlZ3JlZUNyZWRlbnRpYWwiXSwiaXNzdWVyIjoiaHR0cHM6Ly9leGFtcGxlLmVkdS9pc3N1ZXJzLzU2NTA0OSIsImlzc3VhbmNlRGF0ZSI6IjIwMTAtMDEtMDFUMDA6MDA6MDBaIiwiY3JlZGVudGlhbFN1YmplY3QiOnsiaWQiOiJkaWQ6ZXhhbXBsZTplYmZlYjFmNzEyZWJjNmYxYzI3NmUxMmVjMjEiLCJkZWdyZWUiOnsidHlwZSI6IkJhY2hlbG9yRGVncmVlIiwibmFtZSI6IkJhY2hlbG9yIG9mIFNjaWVuY2UgYW5kIEFydHMifX19LCJpc3MiOiJodHRwczovL2V4YW1wbGUuZWR1L2lzc3VlcnMvNTY1MDQ5IiwibmJmIjoxMjYyMzA0MDAwLCJqdGkiOiJodHRwOi8vZXhhbXBsZS5lZHUvY3JlZGVudGlhbHMvMzczMiIsInN1YiI6ImRpZDpleGFtcGxlOmViZmViMWY3MTJlYmM2ZjFjMjc2ZTEyZWMyMSJ9.z5vgMTK1nfizNCg5N-niCOL3WUIAL7nXy-nGhDZYO_-PNGeE-0djCpWAMH8fD8eWSID5PfkPBYkx_dfLJnQ7NA';
+    nock('https://oidc4vci.demo.spruceid.com')
+      .post(/credential/)
+      .reply(200, {
+        format: 'jwt-vc',
+        credential: mockedVC,
+      });
+    const credReqClient = CredentialRequestClientBuilder.fromCredentialOfferRequest({ request: INITIATION_TEST })
+      .withCredentialEndpoint('https://oidc4vci.demo.spruceid.com/credential')
+      .withFormat('jwt_vc')
+      .withCredentialType('https://imsglobal.github.io/openbadges-specification/ob_v3p0.html#OpenBadgeCredential')
+      .build();
+    const proof: ProofOfPossession = await ProofOfPossessionBuilder.fromJwt({
+      jwt,
+      callbacks: {
+        signCallback: proofOfPossessionCallbackFunction,
+      },
+      version: OpenId4VCIVersion.VER_1_0_08,
+    })
+      // .withEndpointMetadata(metadata)
+      .withKid(kid)
+      .withClientId('sphereon:wallet')
+      .build();
+    const credentialRequest = await credReqClient.createCredentialRequest({
+      proofInput: proof,
+      format: 'jwt',
+      version: OpenId4VCIVersion.VER_1_0_08,
+    });
+    expect(credentialRequest.proof?.jwt?.includes(partialJWT)).toBeTruthy();
+    expect(credentialRequest.format).toEqual('jwt_vc_json');
+    const result = await credReqClient.acquireCredentialsUsingRequest(credentialRequest);
+    expect(result?.successBody?.credential).toEqual(mockedVC);
+  });
+
+  it('should fail with invalid url', async () => {
+    const credReqClient = CredentialRequestClientBuilder.fromCredentialOfferRequest({ request: INITIATION_TEST })
+      .withCredentialEndpoint('httpsf://oidc4vci.demo.spruceid.com/credential')
+      .withFormat('jwt_vc')
+      .withCredentialType('https://imsglobal.github.io/openbadges-specification/ob_v3p0.html#OpenBadgeCredential')
+      .build();
+    const proof: ProofOfPossession = await ProofOfPossessionBuilder.fromJwt({
+      jwt,
+      callbacks: {
+        signCallback: proofOfPossessionCallbackFunction,
+      },
+      version: OpenId4VCIVersion.VER_1_0_08,
+    })
+      // .withEndpointMetadata(metadata)
+      .withKid(kid)
+      .withClientId('sphereon:wallet')
+      .build();
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    await expect(credReqClient.acquireCredentialsUsingRequest({ format: 'jwt_vc_json-ld', types: ['random'], proof })).rejects.toThrow(
+      Error(URL_NOT_VALID)
+    );
+  });
+});
+
+describe('Credential Request Client with Walt.id ', () => {
+  it('should have correct metadata endpoints', async function () {
+    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);
+
+    const request = credentialOffer.credential_offer;
+    const metadata = await MetadataClient.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);
+
+    const credReqClient = CredentialRequestClientBuilder.fromCredentialOffer({
+      credentialOffer,
+      metadata,
+    }).build();
+    expect(credReqClient.credentialRequestOpts.credentialEndpoint).toBe(WALT_OID4VCI_METADATA.credential_endpoint);
+  });
+});
+
+describe('Credential Request Client with different issuers ', () => {
+  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';
+    const credentialRequest = await (
+      await CredentialRequestClientBuilder.fromURI({
+        uri: IRR_URI,
+        metadata: getMockData('spruce')?.metadata as unknown as EndpointMetadata,
+      })
+    )
+      .build()
+      .createCredentialRequest({
+        proofInput: {
+          proof_type: 'jwt',
+          jwt: getMockData('spruce')?.credential.request.proof.jwt as string,
+        },
+        credentialTypes: ['OpenBadgeCredential'],
+        format: 'jwt_vc_json-ld',
+        version: OpenId4VCIVersion.VER_1_0_08,
+      });
+    expect(credentialRequest).toEqual(getMockData('spruce')?.credential.request);
+  });
+
+  it('should create correct CredentialRequest for Walt', async () => {
+    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 (
+      await CredentialRequestClientBuilder.fromURI({
+        uri: IRR_URI,
+        metadata: getMockData('walt')?.metadata as unknown as EndpointMetadata,
+      })
+    )
+      .build()
+      .createCredentialRequest({
+        proofInput: {
+          proof_type: 'jwt',
+          jwt: getMockData('walt')?.credential.request.proof.jwt as string,
+        },
+        credentialTypes: ['OpenBadgeCredential'],
+        format: 'jwt_vc',
+        version: OpenId4VCIVersion.VER_1_0_08,
+      });
+    expect(credentialOffer).toEqual(getMockData('walt')?.credential.request);
+  });
+
+  // Missing the issuer required property
+  xit('should create correct CredentialRequest for uniissuer', async () => {
+    const IRR_URI =
+      'https://oidc4vc.uniissuer.io/?credential_type=OpenBadgeCredential&pre-authorized_code=0ApoI8rxVmdQ44RIpuDbFIURIIkOhyek&user_pin_required=false';
+    const credentialOffer = await (
+      await CredentialRequestClientBuilder.fromURI({
+        uri: IRR_URI,
+        metadata: getMockData('uniissuer')?.metadata as unknown as EndpointMetadata,
+      })
+    )
+      .build()
+      .createCredentialRequest({
+        proofInput: {
+          proof_type: 'jwt',
+          jwt: getMockData('uniissuer')?.credential.request.proof.jwt as string,
+        },
+        credentialTypes: ['OpenBadgeCredential'],
+        format: 'jwt_vc',
+        version: OpenId4VCIVersion.VER_1_0_08,
+      });
+    expect(credentialOffer).toEqual(getMockData('uniissuer')?.credential.request);
+  });
+
+  it('should create correct CredentialRequest for mattr', async () => {
+    const IRR_URI =
+      'openid-initiate-issuance://?issuer=https://launchpad.mattrlabs.com&credential_type=OpenBadgeCredential&pre-authorized_code=g0UCOj6RAN5AwHU6gczm_GzB4_lH6GW39Z0Dl2DOOiO';
+    const credentialOffer = await (
+      await CredentialRequestClientBuilder.fromURI({
+        uri: IRR_URI,
+        metadata: getMockData('mattr')?.metadata as unknown as EndpointMetadata,
+      })
+    )
+      .build()
+      .createCredentialRequest({
+        proofInput: {
+          proof_type: 'jwt',
+          jwt: getMockData('mattr')?.credential.request.proof.jwt as string,
+        },
+        credentialTypes: ['OpenBadgeCredential'],
+        format: 'ldp_vc',
+        version: OpenId4VCIVersion.VER_1_0_08,
+      });
+    expect(credentialOffer).toEqual(getMockData('mattr')?.credential.request);
+  });
+
+  it('should create correct CredentialRequest for diwala', async () => {
+    const IRR_URI =
+      'openid-initiate-issuance://?issuer=https://oidc4vc.diwala.io&credential_type=OpenBadgeCredential&pre-authorized_code=eyJhbGciOiJIUzI1NiJ9.eyJjcmVkZW50aWFsX3R5cGUiOiJPcGVuQmFkZ2VDcmVkZW50aWFsIiwiZXhwIjoxNjgxOTg0NDY3fQ.fEAHKz2nuWfiYHw406iNxr-81pWkNkbi31bWsYSf6Ng';
+    const credentialOffer = await (
+      await CredentialRequestClientBuilder.fromURI({
+        uri: IRR_URI,
+        metadata: getMockData('diwala')?.metadata as unknown as EndpointMetadata,
+      })
+    )
+      .build()
+      .createCredentialRequest({
+        proofInput: {
+          proof_type: 'jwt',
+          jwt: getMockData('diwala')?.credential.request.proof.jwt as string,
+        },
+        credentialTypes: ['OpenBadgeCredential'],
+        format: 'ldp_vc',
+        version: OpenId4VCIVersion.VER_1_0_08,
+      });
+    expect(credentialOffer).toEqual(getMockData('diwala')?.credential.request);
+  });
+});