@mattrglobal/verifier-sdk-web 1.1.1-unstable.16 → 1.1.1-unstable.160

package/dist/typings/verifier/types/verifier-web-sdk.d.ts

@@ -1,70 +1,37 @@
 import * as v from "valibot";
 import { BaseError } from "../../common";
-import { CrossDeviceCallbackError } from "../requestCredentialsCrossDevice";
-import { CredentialQuery, PresentationSessionResult } from "./credential-presentation";
+import { CredentialQuery, Mode, PresentationSessionResult } from "./credential-presentation";
 export declare enum LocalStorageKey {
     challenge = "mattr_chg",
     sessionId = "mattr_sid"
 }
-/**
- * The mode in which the credentials are requested
- */
-export declare enum Mode {
-    /**
-     * The credentials are requested on the same device
-     */
-    sameDevice = "sameDevice",
-    /**
-     * The credentials are requested on a different device
-     */
-    crossDevice = "crossDevice"
-}
+export declare const MATTR_SDK_VERSION_HEADER = "x-mattr-sdk-version";
+export declare const MATTR_SDK_VERSION_VALUE = "2.0.0";
 export declare enum MessageEventDataType {
     PresentationCompleted = "PresentationCompleted",// { type: "PresentationCompleted", responseCode, sessionId }
     PresentationTimeout = "PresentationTimeout",// { type: "PresentationTimeout", sessionId }
     PresentationAbort = "PresentationAbort"
 }
 export type SameDeviceRequestCredentialsOptions = {
-    credentialQuery: CredentialQuery[];
-    redirectUri: string;
     challenge: string;
-    mode: Mode.sameDevice;
-    walletProviderId?: string;
-    initialiseOptions: InitialiseOptions;
-};
-export type CrossDeviceCallbackOnCompleteResponse = {
-    /**
-     *  Contains the result of the presentation session if result is configured to be available in the front channel
-     */
-    result: PresentationSessionResult | {
-        sessionId: string;
-    };
+    apiBaseUrl: string;
+    applicationId: string;
+    sessionUrl: string;
+    sessionKey: string;
     sessionId: string;
 };
-export type CrossDeviceCallback = {
-    /**
-     * The function to be executed on completion of the credential request.
-     * @param result
-     */
-    onComplete: (result: CrossDeviceCallbackOnCompleteResponse) => void;
-    /**
-     * The function to be executed on failure of the credential request.
-     * @param error
-     */
-    onFailure: (error: CrossDeviceCallbackError) => void;
-};
 export type CrossDeviceRequestCredentialsOptions = {
-    credentialQuery: CredentialQuery[];
-    crossDeviceCallback: CrossDeviceCallback;
     challenge: string;
-    walletProviderId?: string;
-    mode: Mode.crossDevice;
-    initialiseOptions: InitialiseOptions;
+    apiBaseUrl: string;
+    sessionUrl: string;
+    sessionKey: string;
+    sessionId: string;
 };
 /**
- * Options for the same device requestCredentials function
+ * Options for requestCredentials function without openId4vp configuration.
+ * Can be used for requesting credential with Digital Credentials API or with openId4vp cross-device flow
  */
-export type RequestCredentialsSameDeviceOptions = {
+export type RequestCredentialsBaseOptions = {
     /**
      * An array of CredentialQuery objects that specify the credentials to be requested.
      */
@@ -72,154 +39,83 @@ export type RequestCredentialsSameDeviceOptions = {
     /**
      *  The URI to which the user will be redirected after the credential request is completed.
      */
-    redirectUri: string;
-    /**
-     * An optional challenge string that is used to ensure the security and integrity of the credential request. If not provided, a challenge will be generated by default.
-     */
     challenge?: string;
+};
+/**
+ * Options for openid4vpConfiguration to request credentials with same device
+ */
+export type OpenId4vpConfigurationSameDeviceOptions = {
     /**
      * An optional identifier for wallet configuration. If not provided, the default wallet will be used.
      * This parameter is defined as part of your MATTR VII tenant verifier configuration
      */
     walletProviderId?: string;
     /**
-     * An optional mode in which the credentials are requested. Set to Mode.sameDevice for this type.
+     * A mode in which the credentials are requested. Set to Mode.SameDevice for this type.
+     * Can be undefined
+     */
+    mode: Mode.SameDevice;
+    /**
+     * redirectUri is required if mode is same device or undefined
      */
-    mode: Mode.sameDevice;
+    redirectUri: string;
 };
-export declare const RequestCredentialsSameDeviceOptionsValidator: v.ObjectSchema<{
-    readonly credentialQuery: v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
-        readonly profile: v.PicklistSchema<[import("./credential-presentation").OpenidPresentationCredentialProfileSupported], undefined>;
-        readonly docType: v.StringSchema<undefined>;
-        readonly nameSpaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.StrictObjectSchema<{
-            readonly intentToRetain: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
-        }, undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, v.NonEmptyAction<{
-        profile: import("./credential-presentation").OpenidPresentationCredentialProfileSupported;
-        nameSpaces: {
-            [x: string]: {
-                [x: string]: {
-                    intentToRetain?: boolean | undefined;
-                };
-            };
-        };
-        docType: string;
-    }[], undefined>]>;
-    readonly redirectUri: v.StringSchema<undefined>;
-    readonly challenge: v.OptionalSchema<v.StringSchema<undefined>, never>;
+export declare const OpenId4vpConfigSameDeviceOptionsValidator: v.ObjectSchema<{
     readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
-    readonly mode: v.PicklistSchema<[Mode.sameDevice], undefined>;
+    readonly mode: v.LiteralSchema<Mode.SameDevice, undefined>;
+    readonly redirectUri: v.StringSchema<undefined>;
 }, undefined>;
 /**
- * Options for the cross device requestCredentials function
+ * Options for openid4vpConfiguration to request credentials with cross device
  */
-export type RequestCredentialsCrossDeviceDeviceOptions = {
-    /**
-     * An array of CredentialQuery objects that specify the credentials to be requested.
-     */
-    credentialQuery: CredentialQuery[];
-    /**
-     * The callback functions to be executed on success or failure of the credential request in cross device mode.
-     */
-    crossDeviceCallback: CrossDeviceCallback;
-    /**
-     * An optional challenge string that is used to ensure the security and integrity of the credential request. If not provided, a challenge will be generated by default.
-     */
-    challenge?: string;
+export type OpenId4vpConfigurationCrossDeviceOptions = {
     /**
      * An optional identifier for wallet configuration. If not provided, the default wallet will be used.
      * This parameter is defined as part of your MATTR VII tenant verifier configuration
      */
     walletProviderId?: string;
     /**
-     * An optional mode in which the credentials are requested. Set to Mode.crossDevice for this type.
+     * A mode in which the credentials are requested. Set to Mode.CrossDevice for this type.
      */
-    mode: Mode.crossDevice;
+    mode: Mode.CrossDevice;
 };
-export declare const RequestCredentialsCrossDeviceOptionsValidator: v.ObjectSchema<{
-    readonly credentialQuery: v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
-        readonly profile: v.PicklistSchema<[import("./credential-presentation").OpenidPresentationCredentialProfileSupported], undefined>;
-        readonly docType: v.StringSchema<undefined>;
-        readonly nameSpaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.StrictObjectSchema<{
-            readonly intentToRetain: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
-        }, undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, v.NonEmptyAction<{
-        profile: import("./credential-presentation").OpenidPresentationCredentialProfileSupported;
-        nameSpaces: {
-            [x: string]: {
-                [x: string]: {
-                    intentToRetain?: boolean | undefined;
-                };
-            };
-        };
-        docType: string;
-    }[], undefined>]>;
-    readonly crossDeviceCallback: v.ObjectSchema<{
-        readonly onComplete: v.FunctionSchema<undefined>;
-        readonly onFailure: v.FunctionSchema<undefined>;
-    }, undefined>;
-    readonly challenge: v.OptionalSchema<v.StringSchema<undefined>, never>;
+export declare const OpenId4vpConfigCrossDeviceOptionsValidator: v.ObjectSchema<{
     readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
-    readonly mode: v.PicklistSchema<[Mode.crossDevice], undefined>;
+    readonly mode: v.LiteralSchema<Mode.CrossDevice, undefined>;
 }, undefined>;
 /**
- * Options for auto detect device requestCredentials function
+ * Options for openid4vpConfiguration which allow to auto-detect the device mode
  */
-export type RequestCredentialsAutoDetectOptions = {
-    /**
-     * An array of CredentialQuery objects that specify the credentials to be requested.
-     */
-    credentialQuery: CredentialQuery[];
-    /**
-     * The callback functions to be executed on success or failure of the credential request in cross device mode.
-     */
-    crossDeviceCallback: CrossDeviceCallback;
-    /**
-     *  The URI to which the user will be redirected after the credential request is completed.
-     */
-    redirectUri: string;
-    /**
-     * An optional challenge string that is used to ensure the security and integrity of the credential request. If not provided, a challenge will be generated by default.
-     */
-    challenge?: string;
+export type OpenId4vpConfigurationAutoDetectOptions = {
     /**
      * An optional identifier for wallet configuration. If not provided, the default wallet will be used.
      * This parameter is defined as part of your MATTR VII tenant verifier configuration
      */
     walletProviderId?: string;
+    /**
+     * redirect uri to use for same device mode
+     */
+    redirectUri: string;
     /**
      * An optional mode in which the credentials are requested. If not provided, the mode is determined based on the device (isMobileDetect(navigator.userAgent)).
      */
     mode?: Mode;
 };
-export declare const RequestCredentialsAutoDetectDeviceOptionsValidator: v.GenericSchema<RequestCredentialsAutoDetectOptions>;
+export declare const OpenId4vpConfigAutoDetectOptionsValidator: v.ObjectSchema<{
+    readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
+    readonly redirectUri: v.StringSchema<undefined>;
+    readonly mode: v.OptionalSchema<v.PicklistSchema<[Mode.CrossDevice, Mode.SameDevice], undefined>, never>;
+}, undefined>;
 /**
  * Options for the requestCredentials function
  */
-export type RequestCredentialsOptions = RequestCredentialsSameDeviceOptions | RequestCredentialsCrossDeviceDeviceOptions | RequestCredentialsAutoDetectOptions;
-export declare const RequestCredentialsOptionsValidator: v.UnionSchema<[v.ObjectSchema<{
-    readonly credentialQuery: v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
-        readonly profile: v.PicklistSchema<[import("./credential-presentation").OpenidPresentationCredentialProfileSupported], undefined>;
-        readonly docType: v.StringSchema<undefined>;
-        readonly nameSpaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.StrictObjectSchema<{
-            readonly intentToRetain: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
-        }, undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, v.NonEmptyAction<{
-        profile: import("./credential-presentation").OpenidPresentationCredentialProfileSupported;
-        nameSpaces: {
-            [x: string]: {
-                [x: string]: {
-                    intentToRetain?: boolean | undefined;
-                };
-            };
-        };
-        docType: string;
-    }[], undefined>]>;
-    readonly redirectUri: v.StringSchema<undefined>;
-    readonly challenge: v.OptionalSchema<v.StringSchema<undefined>, never>;
-    readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
-    readonly mode: v.PicklistSchema<[Mode.sameDevice], undefined>;
-}, undefined>, v.ObjectSchema<{
+export type RequestCredentialsOptions = RequestCredentialsBaseOptions & {
+    /**
+     * Optional configuration for openid4vp presentation flow
+     */
+    openid4vpConfiguration?: OpenId4vpConfigurationSameDeviceOptions | OpenId4vpConfigurationCrossDeviceOptions | OpenId4vpConfigurationAutoDetectOptions;
+};
+export declare const RequestCredentialsOptionsValidator: v.ObjectSchema<{
     readonly credentialQuery: v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
         readonly profile: v.PicklistSchema<[import("./credential-presentation").OpenidPresentationCredentialProfileSupported], undefined>;
         readonly docType: v.StringSchema<undefined>;
@@ -237,20 +133,20 @@ export declare const RequestCredentialsOptionsValidator: v.UnionSchema<[v.Object
         };
         docType: string;
     }[], undefined>]>;
-    readonly crossDeviceCallback: v.ObjectSchema<{
-        readonly onComplete: v.FunctionSchema<undefined>;
-        readonly onFailure: v.FunctionSchema<undefined>;
-    }, undefined>;
     readonly challenge: v.OptionalSchema<v.StringSchema<undefined>, never>;
-    readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
-    readonly mode: v.PicklistSchema<[Mode.crossDevice], undefined>;
-}, undefined>, v.GenericSchema<RequestCredentialsAutoDetectOptions, RequestCredentialsAutoDetectOptions, v.BaseIssue<unknown>>], undefined>;
-/**
- * The response from the same device requestCredentials function
- */
-export type SameDeviceRequestCredentialsResponse = {
-    sessionId: string;
-};
+    readonly openid4vpConfiguration: v.OptionalSchema<v.UnionSchema<[v.ObjectSchema<{
+        readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
+        readonly mode: v.LiteralSchema<Mode.SameDevice, undefined>;
+        readonly redirectUri: v.StringSchema<undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
+        readonly mode: v.LiteralSchema<Mode.CrossDevice, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
+        readonly redirectUri: v.StringSchema<undefined>;
+        readonly mode: v.OptionalSchema<v.PicklistSchema<[Mode.CrossDevice, Mode.SameDevice], undefined>, never>;
+    }, undefined>], undefined>, never>;
+}, undefined>;
 export type MessageEvent = {
     data: {
         type: MessageEventDataType;
@@ -260,25 +156,58 @@ export type MessageEvent = {
     origin: string;
 };
 /**
- * The response from the cross device requestCredentials function
+ * The response from the requestCredentials function when credentials were requested with OpenId4vp
  */
-export type CrossDeviceRequestCredentialsResponse = {
+export type RequestCredentialsResponse = {
+    /**
+     *  Contains the result of the presentation session if result is configured to be available in the front channel
+     */
+    result?: PresentationSessionResult;
+    /**
+     *  when frontChannelResultAvailable is set to true
+     */
     sessionId: string;
+    /**
+     *  Indicates that session is completed and the flow will continue on the redirected page
+     */
+    sessionCompletedInRedirect?: boolean;
 };
-/**
- * The response from the requestCredentials function
- */
-export type RequestCredentialsResponse = SameDeviceRequestCredentialsResponse | CrossDeviceRequestCredentialsResponse;
 /**
  * The error type for the requestCredentials function
  */
 export declare enum RequestCredentialsErrorType {
-    RequestCredentialsFailed = "RequestCredentialsFailed"
+    RequestCredentialsFailed = "RequestCredentialsFailed",
+    Timeout = "Timeout",
+    Abort = "Abort"
+}
+export declare enum RequestCredentialsErrorMessage {
+    FailedToGetSessionResult = "Failed to get session result",
+    FailedToGetSessionStatus = "Failed to get session status",
+    FailedToCreateSession = "Failed to create session",
+    FailedToVerifyCredentialResponse = "Failed to verify credential response",
+    MissingOpenId4vpConfig = "Identified openid4vp session, but missing openId4vpConfiguration on `requestCredentials`",
+    DcApiError = "Failed to request credentials with Digital Credentials API",
+    DcApiResponseParseError = "Failed to parse response from Digital Credentials API",
+    Abort = "User aborted the session",
+    Timeout = "User session timeout"
+}
+/**
+ * The error type for the `abortCredentialRequest` function
+ */
+export declare enum AbortSessionErrorType {
+    AbortSessionFailed = "AbortSessionFailed"
+}
+export declare enum AbortSessionErrorMessage {
+    FailedToAbortSession = "Failed to abort session"
 }
 /**
  * The error response from the requestCredentials function
  */
 export type RequestCredentialsError = BaseError<RequestCredentialsErrorType>;
+/**
+ * The error response from the requestCredentials function
+ */
+export type AbortSessionError = BaseError<AbortSessionErrorType>;
 /**
  * The response from the handleRedirectCallback function
  */
@@ -286,19 +215,33 @@ export type HandleRedirectCallbackResponse = {
     /**
      *  Contains the result of the presentation session if result is configured to be available in the front channel
      */
-    result: PresentationSessionResult | {
-        sessionId: string;
-    };
+    result?: PresentationSessionResult;
     sessionId: string;
 };
 /**
- * Options for the initialise function
+ * Options for the initialize function
  */
-export type InitialiseOptions = {
+export type InitializeOptions = {
     apiBaseUrl: string;
-    applicationId?: string;
+    applicationId: string;
 };
-export declare const InitialiseOptionsValidator: v.ObjectSchema<{
-    readonly apiBaseUrl: v.StringSchema<undefined>;
-    readonly applicationId: v.OptionalSchema<v.StringSchema<undefined>, never>;
+export declare const InitializeOptionsValidator: v.ObjectSchema<{
+    readonly apiBaseUrl: v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, "Must not be empty">]>;
+    readonly applicationId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, "Must not be empty">]>;
 }, undefined>;
+/**
+ * Struct for a presentation session
+ */
+export type CreatePresentationSession = {
+    readonly sessionId: string;
+    readonly sessionKey: string;
+    readonly sessionTimeoutId?: number;
+};
+/**
+ * Struct for a stored presentation session
+ */
+export type StoredPresentationSession = {
+    readonly sessionId: string;
+    readonly sessionKey?: string;
+    readonly sessionTimeoutId?: number;
+};

package/dist/typings/verifier/utils.d.ts

@@ -1,6 +1,6 @@
 import { Result } from "neverthrow";
-import { SafeFetchValidateRespondError } from "../common/safeFetch";
-import { CreateSessionRequest, CreateSessionResponse, ExchangeSessionResultResponse, InitialiseOptions } from "./types";
+import { SafeFetchValidateResponseError } from "../common/safeFetch";
+import { CreateSessionRequest, ExchangeSessionResultResponse, GetSessionStatusRequest, GetSessionStatusResponse, AbortSessionRequest, InitializeOptions, CreateSessionResponse } from "./types";
 /**
  * Generates a challenge string using the window.crypto API.
  *
@@ -22,11 +22,27 @@ export declare const getHashParamValue: (hash: string, param: string) => string
  * @param challenge - The challenge for the session.
  * @param redirectUri - The redirect URI for the session.
  * @param apiBaseUrl - The base URL of the API.
- * @param applicationId - optional, The ID of the verifier application, if not provided the default application ID will be used.
+ * @param applicationId - The ID of the verifier application.
  * @param walletProviderId - optional, The ID of the wallet provider, if not provided the default wallet provider will be used.
  * @returns A promise that resolves to a result containing either the created session response or an error.
  */
-export declare const createSession: ({ credentialQuery, challenge, redirectUri, apiBaseUrl, applicationId, walletProviderId, }: CreateSessionRequest & InitialiseOptions) => Promise<Result<CreateSessionResponse, SafeFetchValidateRespondError>>;
+export declare const createSession: ({ credentialQuery, challenge, redirectUri, apiBaseUrl, walletProviderId, dcApiSupported, applicationId, }: CreateSessionRequest & InitializeOptions) => Promise<Result<CreateSessionResponse, SafeFetchValidateResponseError>>;
+/**
+ * Abort a session with the provided parameters.
+ *
+ * @param sessionId - The unique identifier for the session.
+ * @param sessionKey - The authorization key for performing operations for the session.
+ * @returns A promise that resolves to a ok result when succeed or an error.
+ */
+export declare const abortSession: ({ apiBaseUrl, sessionId, sessionKey, }: AbortSessionRequest) => Promise<Result<void, SafeFetchValidateResponseError>>;
+/**
+ * Retrieve the status for a session with the provided parameters.
+ *
+ * @param sessionId - The unique identifier for the session.
+ * @param sessionKey - The authorization key for performing operations for the session.
+ * @returns A promise that resolves to a result containing either the session status response or an error.
+ */
+export declare const getSessionStatus: ({ apiBaseUrl, sessionId, sessionKey, }: GetSessionStatusRequest & InitializeOptions) => Promise<Result<GetSessionStatusResponse, SafeFetchValidateResponseError>>;
 /**
  * Exchange the result of a session using the provided parameters.
  *
@@ -41,7 +57,7 @@ export declare const exchangeSessionResult: ({ challenge, responseCode, sessionI
     responseCode: string;
     sessionId: string;
     apiBaseUrl: string;
-}) => Promise<Result<ExchangeSessionResultResponse, SafeFetchValidateRespondError>>;
+}) => Promise<Result<ExchangeSessionResultResponse, SafeFetchValidateResponseError>>;
 /**
  * Detects if the user agent is a mobile device.
  *
@@ -49,3 +65,7 @@ export declare const exchangeSessionResult: ({ challenge, responseCode, sessionI
  * @returns A boolean indicating whether the user agent is a mobile device.
  */
 export declare const isMobileDetect: (userAgent: string) => boolean;
+/**
+ * Returns the value that is being set in the x-mattr-sdk-version header
+ */
+export declare const getVersion: () => string;