@sphereon/oid4vci-common 0.4.1-unstable.247

package/lib/types/Generic.types.ts

@@ -0,0 +1,215 @@
+import { ICredentialContextType, IVerifiableCredential, W3CVerifiableCredential } from '@sphereon/ssi-types';
+
+import { ProofOfPossession } from './CredentialIssuance.types';
+import { Oauth2ASWithOID4VCIMetadata } from './OpenID4VCIServerMetadata';
+
+/**
+ * Important Note: please be aware that these Common interfaces are based on versions v1_0.11 and v1_0.09
+ */
+export interface CredentialLogo {
+  url?: string;
+  alt_text?: string;
+  [key: string]: unknown;
+}
+
+export enum CredentialFormatEnum {
+  jwt_vc_json = 'jwt_vc_json',
+  jwt_vc_json_ld = 'jwt_vc_json_ld',
+  ldp_vc = 'ldp_vc',
+  mso_mdoc = 'mso_mdoc',
+}
+
+export interface NameAndLocale {
+  name?: string;
+  locale?: string;
+  [key: string]: unknown;
+}
+
+export interface LogoAndColor {
+  logo?: CredentialLogo;
+  background_color?: string;
+  text_color?: string;
+}
+
+export type Display = NameAndLocale & LogoAndColor;
+
+export interface IssuerMetadata {
+  credential_endpoint: string;
+  batch_credential_endpoint?: string;
+  credentials_supported: CredentialSupported[];
+  credential_issuer: string; // REQUIRED. The URL of the Credential Issuer, the Wallet is requested to obtain one or more Credentials from.
+  authorization_server?: string;
+  token_endpoint?: string;
+  display?: Display[];
+}
+
+export interface CredentialSupportedBrief {
+  name?: string;
+  types: string[]; // REQUIRED. JSON array designating the types a certain credential type supports
+  cryptographic_binding_methods_supported?: string[]; // OPTIONAL. Array of case sensitive strings that identify how the Credential is bound to the identifier of the End-User who possesses the Credential
+  cryptographic_suites_supported?: string[]; // OPTIONAL. Array of case sensitive strings that identify the cryptographic suites that are supported for the cryptographic_binding_methods_supported
+}
+export type CommonCredentialSupported = CredentialSupportedBrief & {
+  format: CredentialFormatEnum | string; //REQUIRED. A JSON string identifying the format of this credential, e.g. jwt_vc_json or ldp_vc.
+  id?: string; // OPTIONAL. A JSON string identifying the respective object. The value MUST be unique across all credentials_supported entries in the Credential Issuer Metadata
+  display?: Display[]; // OPTIONAL. An array of objects, where each object contains the display properties of the supported credential for a certain language
+  /**
+   * following properties are non-mso_mdoc specific and we might wanna rethink them when we're going to support mso_mdoc
+   */
+  credentialSubject?: IssuerCredentialSubject; // OPTIONAL. A JSON object containing a list of key value pairs, where the key identifies the claim offered in the Credential. The value MAY be a dictionary, which allows to represent the full (potentially deeply nested) structure of the verifiable credential to be issued.
+  order?: string[]; //An array of claims.display.name values that lists them in the order they should be displayed by the Wallet.
+};
+
+export interface CredentialSupportedJwtVcJsonLdAndLdpVc extends CommonCredentialSupported {
+  '@context': ICredentialContextType[]; // REQUIRED. JSON array as defined in [VC_DATA], Section 4.1.
+}
+
+export type CredentialSupportedJwtVcJson = CommonCredentialSupported;
+
+export type CredentialSupported = CredentialSupportedJwtVcJson | CredentialSupportedJwtVcJsonLdAndLdpVc;
+
+export interface CredentialOfferFormat {
+  format: CredentialFormatEnum;
+  types: string[];
+}
+
+export interface IssuerCredentialDefinition {
+  '@context': ICredentialContextType[];
+  types: string[];
+  credentialSubject: IssuerCredentialSubject;
+}
+
+export interface CredentialOfferCredentialDefinition {
+  '@context': ICredentialContextType[];
+  types: string[];
+  CredentialSubject?: IssuerCredentialSubject;
+}
+
+export enum GrantType {
+  AUTHORIZATION_CODE = 'authorization_code',
+  PRE_AUTHORIZED_CODE = 'urn:ietf:params:oauth:grant-type:pre-authorized_code',
+  PASSWORD = 'password',
+}
+
+export interface CommonAccessTokenRequest {
+  client_id?: string;
+  code?: string;
+  code_verifier?: string;
+  grant_type: GrantType;
+  'pre-authorized_code'?: string;
+  redirect_uri?: string;
+  scope?: string;
+  user_pin?: string;
+}
+
+export enum TokenErrorResponse {
+  invalid_request = 'invalid_request',
+  invalid_grant = 'invalid_grant',
+  invalid_client = 'invalid_client', // this code has been added only in v1_0-11, but I've added this to the common interface. @nklomp is this ok?
+  invalid_scope = 'invalid_scope',
+}
+
+export interface CommonAccessTokenResponse {
+  access_token: string;
+  scope?: string;
+  token_type?: string;
+  expires_in?: number; // in seconds
+  c_nonce?: string;
+  c_nonce_expires_in?: number; // in seconds
+  authorization_pending?: boolean;
+  interval?: number; // in seconds
+}
+
+export interface ErrorResponse extends Response {
+  error: string;
+  error_description?: string;
+  error_uri?: string;
+  state?: string;
+}
+
+export interface CommonCredentialRequest {
+  format: string;
+  proof?: ProofOfPossession;
+}
+
+export interface CredentialRequestJwtVcJson extends CommonCredentialRequest {
+  format: CredentialFormatEnum.jwt_vc_json;
+  types: string[];
+  credentialSubject?: IssuerCredentialSubject;
+}
+
+export interface CredentialRequestJwtVcJsonLdAndLdpVc extends CommonCredentialRequest {
+  format: CredentialFormatEnum.jwt_vc_json_ld | CredentialFormatEnum.ldp_vc;
+  credential_definition: IssuerCredentialDefinition;
+}
+
+export interface CommonCredentialResponse {
+  format: string;
+  credential?: W3CVerifiableCredential;
+  acceptance_token?: string;
+  c_nonce?: string;
+  c_nonce_expires_in?: string;
+}
+
+export interface CredentialResponseJwtVcJsonLdAndLdpVc extends CommonCredentialResponse {
+  format: CredentialFormatEnum.jwt_vc_json_ld | CredentialFormatEnum.ldp_vc;
+  credential: IVerifiableCredential;
+}
+
+export type IssuerCredentialSubjectDisplay = CredentialSubjectDisplay & Record<string, CredentialSubjectDisplay>;
+
+export interface CredentialSubjectDisplay {
+  mandatory?: boolean;
+  value_type?: string;
+  display?: Display[];
+  order?: string[]; // An array of claims.display.name values that lists them in the order they should be displayed by the Wallet.
+}
+
+export interface IssuerCredentialSubject {
+  [key: string]: IssuerCredentialSubjectDisplay;
+}
+
+export interface CredentialResponseJwtVcJson {
+  credential: string;
+}
+
+export interface Grant {
+  authorization_code?: GrantAuthorizationCode;
+  'urn:ietf:params:oauth:grant-type:pre-authorized_code'?: GrantUrnIetf;
+}
+
+export interface GrantAuthorizationCode {
+  /**
+   * OPTIONAL. String value created by the Credential Issuer and opaque to the Wallet that is used to bind the subsequent
+   * Authorization Request with the Credential Issuer to a context set up during previous steps.
+   */
+  issuer_state?: string;
+}
+
+export interface GrantUrnIetf {
+  /**
+   * REQUIRED. The code representing the Credential Issuer's authorization for the Wallet to obtain Credentials of a certain type.
+   */
+  'pre-authorized_code': string;
+  /**
+   * OPTIONAL. Boolean value specifying whether the Credential Issuer expects presentation of a user PIN along with the Token Request
+   * in a Pre-Authorized Code Flow. Default is false.
+   */
+  user_pin_required: boolean;
+}
+
+export const PRE_AUTH_CODE_LITERAL = 'pre-authorized_code';
+
+export enum WellKnownEndpoints {
+  OPENID_CONFIGURATION = '/.well-known/openid-configuration',
+  OAUTH_AS = '/.well-known/oauth-authorization-server',
+  OPENID4VCI_ISSUER = '/.well-known/openid-credential-issuer',
+}
+
+export interface EndpointMetadata {
+  issuer: string;
+  token_endpoint: string;
+  credential_endpoint: string;
+  authorization_endpoint?: string;
+  issuerMetadata?: IssuerMetadata | Oauth2ASWithOID4VCIMetadata;
+}

package/lib/types/OAuth2ASMetadata.ts

@@ -0,0 +1,49 @@
+export interface OAuth2ASMetadata {
+  issuer: string;
+  authorization_endpoint?: string;
+  token_endpoint?: string;
+  token_endpoint_auth_methods_supported?: string[];
+  token_endpoint_auth_signing_alg_values_supported?: string[];
+
+  jwks_uri?: string;
+  registration_endpoint?: string;
+  scopes_supported?: string[];
+  response_types_supported: string[];
+  response_modes_supported?: string[];
+  grant_types_supported?: string[];
+  service_documentation?: string;
+  ui_locales_supported?: string[];
+  op_policy_uri?: string;
+  op_tos_uri?: string;
+
+  revocation_endpoint?: string;
+  revocation_endpoint_auth_methods_supported?: string[];
+  revocation_endpoint_auth_signing_alg_values_supported?: string[];
+
+  introspection_endpoint?: string;
+  code_challenge_methods_supported?: string[];
+
+  pushed_authorization_request_endpoint?: string; // The URL of the pushed authorization request endpoint at which a client can post an authorization request to exchange for a request_uri value usable at the authorization server
+  // Note that the presence of pushed_authorization_request_endpoint is sufficient for a client to determine that it may use the PAR flow. A request_uri value obtained from the PAR endpoint is usable at the authorization endpoint regardless of other authorization server metadata such as request_uri_parameter_supported or require_request_uri_registration
+  require_pushed_authorization_requests?: boolean; // Boolean parameter indicating whether Indicates whether the client is required to use PAR to initiate authorization. If omitted, the default value is false.
+  'pre-authorized_grant_anonymous_access_supported': boolean; // OPTIONAL. A JSON Boolean indicating whether the issuer accepts a Token Request with a Pre-Authorized Code but without a client id. The default is false
+
+  // OIDC values
+  frontchannel_logout_supported?: boolean;
+  frontchannel_logout_session_supported?: boolean;
+  backchannel_logout_supported?: boolean;
+  backchannel_logout_session_supported?: boolean;
+  userinfo_endpoint?: string;
+  check_session_iframe?: string;
+  end_session_endpoint?: string;
+  acr_values_supported?: string[];
+  subject_types_supported?: string[];
+  request_object_signing_alg_values_supported?: string[];
+  display_values_supported?: string[];
+  claim_types_supported?: string[];
+  claims_supported?: string[];
+  claims_parameter_supported?: boolean;
+
+  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+  [x: string]: any; //We use any, so you can access properties if you know the structure
+}

package/lib/types/OpenID4VCIErrors.ts

@@ -0,0 +1,35 @@
+import { Alg } from './CredentialIssuance.types';
+
+export const BAD_PARAMS = 'Wrong parameters provided';
+export const URL_NOT_VALID = 'Request url is not valid';
+export const JWS_NOT_VALID = 'JWS is not valid';
+export const PROOF_CANT_BE_CONSTRUCTED = "Proof can't be constructed.";
+export const NO_JWT_PROVIDED = 'No JWT provided';
+export const TYP_ERROR = 'Typ must be "openid4vci-proof+jwt"';
+export const ALG_ERROR = `Algorithm is a required field and must be one of: ${Object.keys(Alg).join(', ')}`;
+export const KID_JWK_X5C_ERROR = 'Only one must be present: kid, jwk or x5c';
+export const AUD_ERROR = 'aud must be the URL of the credential issuer';
+export const IAT_ERROR = 'iat must be the time at which the proof was issued';
+export const NONCE_ERROR = 'nonce must be c_nonce provided by the credential issuer';
+export const JWT_VERIFY_CONFIG_ERROR = 'JWT verify callback not configured correctly.';
+export const ISSUER_CONFIG_ERROR = 'Issuer not configured correctly.';
+export const UNKNOWN_CLIENT_ERROR = 'The client is not known by the issuer';
+export const NO_ISS_IN_AUTHORIZATION_CODE_CONTEXT = 'iss missing in authorization-code context';
+export const ISS_PRESENT_IN_PRE_AUTHORIZED_CODE_CONTEXT = 'iss should be omitted in pre-authorized-code context';
+export const ISS_MUST_BE_CLIENT_ID = 'iss must be the client id';
+export const GRANTS_MUST_NOT_BE_UNDEFINED = 'Grants must not be undefined';
+export const C_NONCE_MISSING_ERROR = 'c_nonce must be present';
+export const CREDENTIAL_MISSING_ERROR = 'Credential must be present in response';
+export const UNSUPPORTED_GRANT_TYPE_ERROR = 'unsupported grant_type';
+export const PRE_AUTHORIZED_CODE_REQUIRED_ERROR = 'pre-authorized_code is required';
+export const USER_PIN_REQUIRED_ERROR = 'User pin is required';
+export const USER_PIN_NOT_REQUIRED_ERROR = 'User pin is not required';
+export const PIN_VALIDATION_ERROR = 'PIN must consist of maximum 8 numeric characters';
+export const PIN_NOT_MATCH_ERROR = 'PIN is invalid';
+export const INVALID_PRE_AUTHORIZED_CODE = 'pre-authorized_code is invalid';
+export const EXPIRED_PRE_AUTHORIZED_CODE = 'pre-authorized_code is expired';
+export const JWT_SIGNER_CALLBACK_REQUIRED_ERROR = 'JWT signer callback function is required';
+export const STATE_MANAGER_REQUIRED_ERROR = 'StateManager instance is required';
+export const NONCE_STATE_MANAGER_REQUIRED_ERROR = 'NonceStateManager instance is required';
+export const PIN_NOT_MATCHING_ERROR = 'PIN does not match';
+export const ACCESS_TOKEN_ISSUER_REQUIRED_ERROR = 'access token issuer is required';

package/lib/types/OpenID4VCIServerMetadata.ts

@@ -0,0 +1,31 @@
+import { CredentialFormat } from '@sphereon/ssi-types';
+
+import { Display, IssuerCredentialSubject, IssuerMetadata } from './Generic.types';
+import { OAuth2ASMetadata } from './OAuth2ASMetadata';
+
+export type Oauth2ASWithOID4VCIMetadata = OAuth2ASMetadata & IssuerMetadata;
+
+export interface CredentialIssuer {
+  display?: Display; //OPTIONAL. An array of objects, where each object contains display properties of a Credential issuer for a certain language. Below is a non-exhaustive list of valid parameters that MAY be included:
+}
+
+// https://openid.net/specs/openid-4-verifiable-credential-issuance-1_0.html#name-credential-metadata-object
+export interface CredentialMetadata {
+  display?: Display[]; //OPTIONAL. An array of objects, where each object contains display properties of a certain Credential for a certain language. Below is a non-exhaustive list of parameters that MAY be included. Note that the display name of the Credential is obtained from display.name and individual claim names from claims.display.name values.
+  formats: Formats; //REQUIRED. A JSON object containing a list of key value pairs, where the key is a string identifying the format of the Credential. Below is a non-exhaustive list of valid key values defined by this specification:
+  claims?: IssuerCredentialSubject; //REQUIRED. A JSON object containing a list of key value pairs, where the key identifies the claim offered in the Credential. The value is a JSON object detailing the specifics about the support for the claim
+}
+
+export type OpenID4VCICredentialFormatTypes = CredentialFormat | 'mdl_iso' | 'ac_vc' | string;
+
+export interface CredentialFormatSupport {
+  types: string[]; //REQUIRED. Array of strings representing a format specific type of a Credential. This value corresponds to type in W3C [VC_DATA] and a doctype in ISO/IEC 18013-5 (mobile Driving License).
+  cryptographic_binding_methods_supported?: string[]; //OPTIONAL. Array of case sensitive strings that identify how the Credential is bound to the identifier of the End-User who possesses the Credential as defined in Section 9.1. A non-exhaustive list of valid values defined by this specification are did, jwk, and mso.
+  cryptographic_suites_supported?: string[]; //OPTIONAL. Array of case sensitive strings that identify the cryptographic suites that are supported for the cryptographic_binding_methods_supported. Cryptosuites for Credentials in jwt_vc format should use algorithm names defined in IANA JOSE Algorithms Registry. Cryptosuites for Credentials in ldp_vc format should use signature suites names defined in Linked Data Cryptographic Suite Registry.
+  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+  [x: string]: any; //We use any, so you can access properties if you know the structure
+}
+
+export type Formats = {
+  [format in OpenID4VCICredentialFormatTypes]: CredentialFormatSupport;
+};

package/lib/types/OpenID4VCIVersions.types.ts

@@ -0,0 +1,10 @@
+export enum OpenId4VCIVersion {
+  VER_1_0_09 = 1009,
+  VER_1_0_11 = 1011,
+  VER_UNKNOWN = Number.MIN_VALUE,
+}
+
+export enum DefaultURISchemes {
+  INITIATE_ISSUANCE = 'openid-initiate-issuance',
+  CREDENTIAL_OFFER = 'openid-credential-offer',
+}

package/lib/types/StateManager.types.ts

@@ -0,0 +1,29 @@
+import { CredentialOfferV1_0_11 } from './v1_0_11.types';
+
+export interface CredentialOfferState {
+  clientId?: string;
+  credentialOffer: CredentialOfferV1_0_11;
+  createdOn: number;
+  userPin?: number;
+}
+
+export interface CNonceState {
+  cNonce: string;
+  createdOn: number;
+}
+
+export interface IStateManager<T> {
+  setState(state: string, payload: T): Promise<void>;
+
+  getState(state: string): Promise<T | undefined>;
+
+  hasState(state: string): Promise<boolean>;
+
+  deleteState(state: string): Promise<boolean>;
+
+  clearExpiredStates(timestamp?: number): Promise<void>; // clears all expired states compared against timestamp if provided, otherwise current timestamp
+
+  clearAllStates(): Promise<void>; // clears all states
+
+  getAssertedState(issuerState: string): Promise<T>;
+}

package/lib/types/index.ts

@@ -0,0 +1,11 @@
+export * from './Authorization.types';
+export * from './CredentialIssuance.types';
+export * from './Generic.types';
+export * from './v1_0_08.types';
+export * from './v1_0_09.types';
+export * from './v1_0_11.types';
+export * from './OAuth2ASMetadata';
+export * from './OpenID4VCIErrors';
+export * from './OpenID4VCIServerMetadata';
+export * from './OpenID4VCIVersions.types';
+export { CredentialOfferState, IStateManager, CNonceState } from '../types/StateManager.types';

package/lib/types/v1_0_08.types.ts

@@ -0,0 +1,25 @@
+import { CredentialSupportedBrief, Display, IssuerCredentialSubject } from './Generic.types';
+export interface IssuerMetadataV1_0_08 {
+  issuer?: string;
+  credential_endpoint: string;
+  credentials_supported: CredentialSupportedTypeV1_0_08;
+  credential_issuer?: {
+    display: Display | Display[];
+  };
+  authorization_server?: string;
+  token_endpoint?: string;
+  display?: Display[];
+  [x: string]: unknown;
+}
+
+export interface CredentialSupportedTypeV1_0_08 {
+  [credentialType: string]: CredentialSupportedV1_0_08;
+}
+
+export interface CredentialSupportedV1_0_08 {
+  display?: Display[];
+  formats: {
+    [credentialFormat: string]: CredentialSupportedBrief;
+  };
+  claims?: IssuerCredentialSubject;
+}

package/lib/types/v1_0_09.types.ts

@@ -0,0 +1,27 @@
+import { CommonAuthorizationRequest } from './Authorization.types';
+import { CredentialOfferPayload } from './CredentialIssuance.types';
+import { CredentialOfferFormat } from './Generic.types';
+
+// https://openid.net/specs/openid-4-verifiable-credential-issuance-1_0-09.html#name-issuance-initiation-request
+export interface CredentialOfferPayloadV1_0_09 {
+  issuer: string; //(url) REQUIRED The issuer URL of the Credential issuer, the Wallet is requested to obtain one or more Credentials from.
+  credential_type: string[] | string; //(url) REQUIRED A JSON string denoting the type of the Credential the Wallet shall request
+  credentials: CredentialOfferFormat[];
+  'pre-authorized_code'?: string; //CONDITIONAL the code representing the issuer's authorization for the Wallet to obtain Credentials of a certain type. This code MUST be short-lived and single-use. MUST be present in a pre-authorized code flow.
+  user_pin_required?: boolean | string; //OPTIONAL Boolean value specifying whether the issuer expects presentation of a user PIN along with the Token Request in a pre-authorized code flow. Default is false.
+  op_state?: string; //(JWT) OPTIONAL String value created by the Credential Issuer and opaque to the Wallet that is used to bind the subsequent authentication request with the Credential Issuer to a context set up during previous steps
+}
+
+export interface AuthorizationRequestV1_0_09 extends CommonAuthorizationRequest {
+  op_state?: string;
+}
+
+// todo https://sphereon.atlassian.net/browse/VDX-185
+export function isAuthorizationRequestV1_0_09(request: CommonAuthorizationRequest): boolean {
+  return request && 'op_state' in request;
+}
+
+// TODO https://sphereon.atlassian.net/browse/VDX-184
+export function isCredentialOfferV1_0_09(request: CredentialOfferPayload): boolean {
+  return request && ('issuer' in request || 'op_state' in request);
+}

package/lib/types/v1_0_11.types.ts

@@ -0,0 +1,63 @@
+import { AuthorizationDetailsJwtVcJson, CommonAuthorizationRequest } from './Authorization.types';
+import { CredentialOfferPayload } from './CredentialIssuance.types';
+import { CredentialOfferFormat, Grant, IssuerCredentialDefinition } from './Generic.types';
+
+export interface CredentialOfferV1_0_11 {
+  credential_offer?: CredentialOfferPayloadV1_0_11;
+  credential_offer_uri?: string;
+}
+
+export interface CommonCredentialOfferPayloadV1_0_11 {
+  credential_issuer: string; // REQUIRED. The URL of the Credential Issuer, the Wallet is requested to obtain one or more Credentials from.
+
+  /**
+   * REQUIRED. A JSON array, where every entry is a JSON object or a JSON string. If the entry is an object,
+   * the object contains the data related to a certain credential type the Wallet MAY request.
+   * Each object MUST contain a format Claim determining the format of the credential to be requested and
+   * further parameters characterising the type of the credential to be requested as defined in Appendix E.
+   * If the entry is a string, the string value MUST be one of the id values in one of the objects in the
+   * credentials_supported Credential Issuer metadata parameter.
+   * When processing, the Wallet MUST resolve this string value to the respective object.
+   */
+  credentials: (CredentialOfferFormat | string)[];
+  /**
+   * OPTIONAL. A JSON object indicating to the Wallet the Grant Types the Credential Issuer's AS is prepared
+   * to process for this credential offer. Every grant is represented by a key and an object.
+   * The key value is the Grant Type identifier, the object MAY contain parameters either determining the way
+   * the Wallet MUST use the particular grant and/or parameters the Wallet MUST send with the respective request(s).
+   * If grants is not present or empty, the Wallet MUST determine the Grant Types the Credential Issuer's AS supports
+   * using the respective metadata. When multiple grants are present, it's at the Wallet's discretion which one to use.
+   */
+  grants?: Grant;
+}
+
+export interface CredentialOfferJwtVcJsonLdAndLdpVcV1_0_11 extends CommonCredentialOfferPayloadV1_0_11 {
+  /**
+   * REQUIRED. JSON object containing (and isolating) the detailed description of the credential type.
+   * This object MUST be processed using full JSON-LD processing. It consists of the following sub-claims:
+   *   - @context: REQUIRED. JSON array as defined in Appendix E.1.3.2
+   *   - types: REQUIRED. JSON array as defined in Appendix E.1.3.2.
+   *            This claim contains the type values the Wallet shall request in the subsequent Credential Request
+   */
+  credential_definition: IssuerCredentialDefinition;
+}
+
+export interface CredentialOfferJwtVcJsonV1_0_11 extends CommonCredentialOfferPayloadV1_0_11 {
+  credentials: (CredentialOfferFormat | string)[]; // look at CommonCredentialOfferPayloadV1_0_11.credentials
+}
+
+export type CredentialOfferPayloadV1_0_11 = CredentialOfferJwtVcJsonLdAndLdpVcV1_0_11 | CredentialOfferJwtVcJsonV1_0_11;
+
+export interface AuthorizationRequestV1_0_11 extends AuthorizationDetailsJwtVcJson, AuthorizationDetailsJwtVcJson {
+  issuer_state?: string;
+}
+
+// todo https://sphereon.atlassian.net/browse/VDX-185
+export function isAuthorizationRequestV1_0_11(request: CommonAuthorizationRequest): boolean {
+  return request && 'issuer_state' in request;
+}
+
+// TODO https://sphereon.atlassian.net/browse/VDX-184
+export function isCredentialOfferV1_0_11(request: CredentialOfferPayload | CredentialOfferV1_0_11): boolean {
+  return request && ('credential_offer' in request || 'credential_offer_uri' in request || 'credential_issuer' in request);
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@sphereon/oid4vci-common",
+  "version": "0.4.1-unstable.247+0bbe17c",
+  "description": "OpenID 4 Verifiable Credential Issuance Common Types",
+  "source": "lib/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@sphereon/ssi-types": "^0.9.0",
+    "jwt-decode": "^3.1.2"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "files": [
+    "lib/**/*",
+    "dist/**/*"
+  ],
+  "prettier": {
+    "singleQuote": true,
+    "printWidth": 150
+  },
+  "keywords": [
+    "Sphereon",
+    "Verifiable Credentials",
+    "OpenID",
+    "OpenID for Verifiable Credential Issuance",
+    "OAuth2",
+    "SSI",
+    "OpenID4VCI",
+    "OIDC4VCI",
+    "OID4VCI"
+  ],
+  "author": "Sphereon",
+  "license": "Apache-2.0",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "0bbe17c13de4df95e2fd79b3470a746cc7a5374a"
+}