@prove-identity/prove-auth 2.14.0 → 2.15.1

package/build/lib/proveauth/internal/mobile-instantlink-step.js

@@ -9,7 +9,6 @@ const phone_number_input_1 = require("./phone-number-input");
 const auth_error_1 = __importDefault(require("./auth-error"));
 const auth_status_actions_1 = require("./auth-status-actions");
 const mobile_otp_step_1 = __importDefault(require("./mobile-otp-step"));
-const SIMULATED_LINK_CLICK_DELAY = 100;
 class MobileInstantLinkStep extends auth_status_actions_1.AuthStatusActions {
     constructor(startStep, retryStep, getDeviceIp) {
         super();
@@ -19,16 +18,8 @@ class MobileInstantLinkStep extends auth_status_actions_1.AuthStatusActions {
         this.retryStep = retryStep;
         this.getDeviceIp = getDeviceIp !== null && getDeviceIp !== void 0 ? getDeviceIp : (() => null);
     }
-    isTestMode(session) {
-        var _a, _b, _c;
-        var testMode = false;
-        if ((_c = (_b = (_a = session.claims) === null || _a === void 0 ? void 0 : _a.auth.subs.mob) === null || _b === void 0 ? void 0 : _b.auths.inln) === null || _c === void 0 ? void 0 : _c.tme) {
-            testMode = true;
-        }
-        return testMode;
-    }
     execute(session) {
-        this.log.trace('Executing');
+        this.log.debug('Executing');
         return new Promise((resolve, reject) => {
             var _a, _b, _c;
             var phoneNumberNeeded = true;
@@ -40,34 +31,6 @@ class MobileInstantLinkStep extends auth_status_actions_1.AuthStatusActions {
             this.waitForStatus(session).then(resolve).catch(reject);
         });
     }
-    getInstantLinkError(responseData) {
-        const errorCode = responseData.code;
-        var errorMessage = '';
-        if (errorCode) {
-            errorMessage += `Error Code: ${responseData.code}, `;
-        }
-        let instantLinkError;
-        if (errorCode === 10005) {
-            if (responseData.message) {
-                errorMessage += `${responseData.message}`;
-            }
-            else {
-                errorMessage += `Max number of retires reached.`;
-            }
-            instantLinkError = new instantlink_1.InstantLinkMaxRetryError(errorMessage, responseData.code);
-        }
-        else {
-            if (responseData.message) {
-                errorMessage += `${responseData.message}`;
-            }
-            else {
-                errorMessage += `Error validating phone number`;
-            }
-            instantLinkError = new phone_number_input_1.PhoneValidationError(errorMessage, responseData.code);
-        }
-        this.log.error(`Server reports instant link error: ${errorMessage}`);
-        return instantLinkError;
-    }
     runStartStep(session, phoneNumberNeeded, instantLinkError) {
         return new Promise((resolve, reject) => {
             if (this.startStep) {
@@ -90,50 +53,30 @@ class MobileInstantLinkStep extends auth_status_actions_1.AuthStatusActions {
                                 reject(new auth_error_1.default(authResponse.error.message, authResponse.error.code, response.next, false));
                             }
                             else if (authResponse.data) {
-                                const errorCode = authResponse.data.code;
+                                const data = authResponse.data;
+                                const errorCode = data.code;
                                 var errorMessage = '';
                                 if (errorCode) {
-                                    errorMessage += `Error Code: ${authResponse.data.code}, `;
+                                    errorMessage += `Error Code: ${errorCode}, `;
                                 }
-                                if (errorCode === 10005) {
-                                    if (authResponse.data.message) {
-                                        errorMessage += `${authResponse.data.message}`;
-                                    }
-                                    else {
-                                        errorMessage += `Max number of retires reached.`;
-                                    }
-                                    let maxRetryError = new instantlink_1.InstantLinkMaxRetryError(errorMessage, authResponse.data.code);
-                                    if (this.retryStep) {
-                                        this.runRetryStep(session, maxRetryError).then(resolve).catch(reject);
-                                    }
-                                    else {
-                                        this.log.error('Max number of retires reached but retry step is undefined.');
-                                    }
+                                if (data.message) {
+                                    errorMessage += `${data.message}`;
                                 }
                                 else {
-                                    if (authResponse.data.message) {
-                                        errorMessage += `${authResponse.data.message}`;
-                                    }
-                                    else {
-                                        errorMessage += `Error validating phone number.`;
-                                    }
-                                    let invalidPhoneError = new phone_number_input_1.PhoneValidationError(errorMessage, authResponse.data.code);
-                                    this.runStartStep(session, phoneNumberNeeded, invalidPhoneError)
-                                        .then(resolve)
-                                        .catch(reject);
+                                    errorMessage += `Error validating phone number.`;
                                 }
+                                let invalidPhoneError = new phone_number_input_1.PhoneValidationError(errorMessage, data.code);
+                                this.runStartStep(session, phoneNumberNeeded, invalidPhoneError)
+                                    .then(resolve)
+                                    .catch(reject);
                             }
                             else {
-                                this.handleTestMode(session)
-                                    .then(() => {
-                                    if (this.retryStep) {
-                                        this.runRetryStep(session).then(resolve).catch(reject);
-                                    }
-                                    else {
-                                        resolve(authResponse.next);
-                                    }
-                                })
-                                    .catch(reject);
+                                if (this.retryStep) {
+                                    this.runRetryStep(session).then(resolve).catch(reject);
+                                }
+                                else {
+                                    resolve(authResponse.next);
+                                }
                             }
                         })
                             .catch(reject);
@@ -146,11 +89,11 @@ class MobileInstantLinkStep extends auth_status_actions_1.AuthStatusActions {
             }
         });
     }
-    runRetryStep(session, instantLinkError) {
+    runRetryStep(session) {
         return new Promise((resolve, reject) => {
             if (this.retryStep) {
                 this.retryStep
-                    .execute(instantLinkError)
+                    .execute()
                     .then((resultType) => {
                     if (resultType === instantlink_1.InstantLinkResultType.OnResend) {
                         session
@@ -163,26 +106,8 @@ class MobileInstantLinkStep extends auth_status_actions_1.AuthStatusActions {
                             if (authResponse.error) {
                                 reject(new auth_error_1.default(authResponse.error.message, authResponse.error.code, response.next, false));
                             }
-                            else if (authResponse.data) {
-                                const errorCode = authResponse.data.code;
-                                var errorMessage = '';
-                                if (errorCode) {
-                                    errorMessage += `Error Code: ${authResponse.data.code}, `;
-                                }
-                                if (authResponse.data.message) {
-                                    errorMessage += `${authResponse.data.message}`;
-                                }
-                                else {
-                                    errorMessage += `Max number of retires reached.`;
-                                }
-                                let maxRetryError = new instantlink_1.InstantLinkMaxRetryError(errorMessage, authResponse.data.code);
-                                this.runRetryStep(session, maxRetryError).then(resolve).catch(reject);
-                            }
                             else {
-                                this.handleTestMode(session)
-                                    .then(() => this.runRetryStep(session))
-                                    .then(resolve)
-                                    .catch(reject);
+                                this.runRetryStep(session);
                             }
                         })
                             .catch(reject);
@@ -191,42 +116,17 @@ class MobileInstantLinkStep extends auth_status_actions_1.AuthStatusActions {
                         this.runStartStep(session, true).then(resolve).catch(reject);
                     }
                     else {
-                        this.log.warn('Unkown enum of ', resultType);
+                        this.log.warn('Unknown enum of ', resultType);
                     }
                 })
                     .catch(reject);
             }
             else {
-                this.log.debug("Retry step doesn't exsist, skip.");
+                this.log.debug("Retry step doesn't exist, skip.");
                 resolve('');
             }
         });
     }
-    handleTestMode(session) {
-        return new Promise((resolve, reject) => {
-            if (this.isTestMode(session)) {
-                this.log.info('Simulating user clicking the instant link');
-                setTimeout(() => {
-                    session.platform
-                        .fetch(session.backendOrigin +
-                        '/v1/client/mobile/instantlink/finish?token=' +
-                        encodeURIComponent(session.authToken) +
-                        '&vfp=test-vfp', {
-                        mode: 'no-cors',
-                        method: 'GET',
-                    })
-                        .then(() => resolve)
-                        .catch((e) => {
-                        this.log.error('Calling AuthFinish in test mode has failed: ', auth_error_1.default.extractMessage(e));
-                        reject(e);
-                    });
-                }, SIMULATED_LINK_CLICK_DELAY);
-            }
-            else {
-                resolve();
-            }
-        });
-    }
 }
 MobileInstantLinkStep.NAME = 'mobile/instantlink';
 exports.default = MobileInstantLinkStep;

package/build/lib/proveauth/internal/mobile-otp-step.js

@@ -69,7 +69,7 @@ class MobileOtpStep {
                             reject(new auth_error_1.default(authResponse.error.message, authResponse.error.code, response.next, false));
                         }
                         else if (authResponse.data) {
-                            let data = authResponse.data;
+                            const data = authResponse.data;
                             var errorMessage = '';
                             if (data === null || data === void 0 ? void 0 : data.code) {
                                 errorMessage += `Error Code: ${data.code}, `;
@@ -170,7 +170,7 @@ class MobileOtpStep {
                                     reject(new auth_error_1.default(authResponse.error.message, authResponse.error.code, response.next, false));
                                 }
                                 else if (authResponse.data) {
-                                    let data = authResponse.data;
+                                    const data = authResponse.data;
                                     var errorMessage = '';
                                     if (data === null || data === void 0 ? void 0 : data.code) {
                                         errorMessage += `Error Code: ${data.code}, `;
@@ -181,7 +181,7 @@ class MobileOtpStep {
                                     else {
                                         errorMessage += `Error validating OTP`;
                                     }
-                                    let otpError = new otp_1.OtpError(errorMessage, data === null || data === void 0 ? void 0 : data.code);
+                                    const otpError = new otp_1.OtpError(errorMessage, data === null || data === void 0 ? void 0 : data.code);
                                     this.log.error(`Server reports invalid OTP: ${errorMessage}`);
                                     this.runOtpFinishStep(session, otpStartStep, otpFinishStep, phoneNumberNeeded, otpError)
                                         .then(resolve)

package/build/lib/proveauth/internal/platform.d.ts

@@ -4,6 +4,7 @@ import { AuthRequest } from './auth-request';
 import AuthResponse from './auth-response';
 import DeviceAuth, { DeviceRegistration } from './device-auth';
 import { Agent } from '@fingerprintjs/fingerprintjs-pro';
+import { PpbOperation } from '../ppb';
 export declare const DEVICE_CAPABILITY_WEBAUTHN = "webauthn";
 export interface MessageChannel {
     addEventListener: (type: string, listener: (event: any) => void) => void;
@@ -27,6 +28,15 @@ export interface AuthSessionIntegration {
     getDeviceRegistration: () => Promise<DeviceRegistration | null>;
     fetchFromBackend: (query: string, body: AuthRequest) => Promise<AuthResponse>;
 }
+export interface PpbAuthResult {
+    authIdSuccess?: boolean;
+}
+export interface PpbAuthOptions {
+    authIdEndpointUrl?: string;
+    authIdOperation?: PpbOperation;
+    authIdOperationId?: string;
+    authIdOneTimeSecret?: string;
+}
 export default interface Platform {
     readonly webauthn: WebAuthN;
     readonly deviceAuth: DeviceAuth;
@@ -43,6 +53,7 @@ export default interface Platform {
     getFpPromise: () => Promise<Agent> | undefined;
     setFpPromise: (fpPromise: Promise<Agent>) => void;
     getOrigin: () => string;
+    ppbAuthenticate: (options: PpbAuthOptions) => Promise<PpbAuthResult>;
 }
 export declare function stringToArrayBuffer(input: string): ArrayBuffer;
 export declare function arrayBufferToString(input: ArrayBuffer): string;

package/build/lib/proveauth/internal/report-error-step.js

@@ -16,6 +16,7 @@ const mobile_otp_step_1 = __importDefault(require("./mobile-otp-step"));
 const user_present_step_1 = __importDefault(require("./user-present-step"));
 const device_passive_stepup_step_1 = __importDefault(require("./device-passive-stepup-step"));
 const device_universal_redirect_steps_1 = require("./device-universal-redirect-steps");
+const user_ppb_steps_1 = require("./user-ppb-steps");
 class ReportErrorStep {
     constructor(error) {
         this.logger = logger_1.LoggerFactory.getLogger('report-error-step');
@@ -82,11 +83,13 @@ ReportErrorStep.endpointMap = new Map([
     [device_passive_register_step_1.default.NAME, 'device/fido2'],
     [device_passive_verify_step_1.default.NAME, 'device/fido2'],
     [device_passive_stepup_step_1.default.NAME, 'device/fido2'],
+    [device_universal_redirect_steps_1.DeviceUniversalRedirectExchangeStep.NAME, 'device/universal'],
+    [device_universal_redirect_steps_1.DeviceUniversalRedirectFinishStep.NAME, 'device/universal'],
     [mobile_instant_step_1.default.NAME, 'mobile/instant'],
     [mobile_instantlink_step_1.default.NAME, 'mobile/instantlink'],
     [mobile_otp_step_1.default.NAME, 'mobile/otp'],
     [user_present_step_1.default.NAME, 'user/mobileactive'],
-    [device_universal_redirect_steps_1.DeviceUniversalRedirectExchangeStep.NAME, 'device/universal'],
-    [device_universal_redirect_steps_1.DeviceUniversalRedirectFinishStep.NAME, 'device/universal'],
+    [user_ppb_steps_1.UserPpbEnrollStep.NAME, 'user/ppb'],
+    [user_ppb_steps_1.UserPpbVerifyStep.NAME, 'user/ppb'],
 ]);
 exports.default = ReportErrorStep;

package/build/lib/proveauth/internal/user-mobileactive-step.js

@@ -9,9 +9,7 @@ class UserMobileActiveStep {
         this.name = UserMobileActiveStep.NAME;
     }
     execute(session) {
-        return new Promise((resolve, reject) => {
-            reject(new auth_error_1.default(`Step ${this.name} is not supported yet`));
-        });
+        return Promise.reject(new auth_error_1.default(`Step ${this.name} is not supported`));
     }
 }
 UserMobileActiveStep.NAME = 'user/mobileactive';

package/build/lib/proveauth/internal/user-ppb-steps.d.ts

@@ -0,0 +1,24 @@
+import AuthStep from './auth-step';
+import AuthSession from './auth-session';
+import { PpbFinishStep, PpbOperation, PpbStartStep } from '../ppb';
+declare abstract class UserPpbBaseStep implements AuthStep {
+    readonly name: string;
+    private readonly log;
+    private readonly enabled;
+    private readonly operation;
+    private readonly startStep;
+    private readonly finishStep;
+    constructor(enabled: boolean, operation: PpbOperation, startStep?: PpbStartStep, finishStep?: PpbFinishStep);
+    execute(session: AuthSession): Promise<string>;
+}
+export declare class UserPpbEnrollStep extends UserPpbBaseStep {
+    static readonly NAME = "user/ppb/register";
+    readonly name = "user/ppb/register";
+    constructor(enabled: boolean, startStep?: PpbStartStep, finishStep?: PpbFinishStep);
+}
+export declare class UserPpbVerifyStep extends UserPpbBaseStep {
+    static readonly NAME = "user/ppb/verify";
+    readonly name = "user/ppb/verify";
+    constructor(enabled: boolean, startStep?: PpbStartStep, finishStep?: PpbFinishStep);
+}
+export {};

package/build/lib/proveauth/internal/user-ppb-steps.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserPpbVerifyStep = exports.UserPpbEnrollStep = void 0;
+const logger_1 = require("../common/logger");
+const auth_error_1 = __importDefault(require("./auth-error"));
+class UserPpbBaseStep {
+    constructor(enabled, operation, startStep, finishStep) {
+        this.log = logger_1.LoggerFactory.getLogger('user-ppb-base-step');
+        this.enabled = enabled;
+        this.operation = operation;
+        this.startStep = startStep;
+        this.finishStep = finishStep;
+    }
+    execute(session) {
+        if (!this.enabled) {
+            return Promise.reject(new auth_error_1.default('PPB is not enabled'));
+        }
+        const data = session.lastData;
+        if (!data || !data.ppb) {
+            return Promise.reject(new auth_error_1.default('PPB session is not initialized'));
+        }
+        return new Promise((resolve, reject) => {
+            const callStart = () => {
+                try {
+                    if (this.startStep) {
+                        return this.startStep.execute(this.operation);
+                    }
+                    else {
+                        return Promise.resolve();
+                    }
+                }
+                catch (e) {
+                    this.log.warn('PPB start step has failed:', e);
+                    return Promise.reject(e);
+                }
+            };
+            const callFinish = (error) => {
+                try {
+                    if (this.finishStep) {
+                        return this.finishStep.execute(this.operation, error);
+                    }
+                    else {
+                        return Promise.resolve();
+                    }
+                }
+                catch (e) {
+                    this.log.warn('PPB finish step has failed:', e);
+                    return Promise.reject(e);
+                }
+            };
+            callStart()
+                .then(() => {
+                var _a, _b, _c, _d, _e;
+                return session.platform.ppbAuthenticate({
+                    authIdOperation: this.operation,
+                    authIdEndpointUrl: (_c = (_b = (_a = session.claims) === null || _a === void 0 ? void 0 : _a.auth.subs.usr) === null || _b === void 0 ? void 0 : _b.auths.ppb) === null || _c === void 0 ? void 0 : _c.endp,
+                    authIdOperationId: (_d = data.ppb) === null || _d === void 0 ? void 0 : _d.operationId,
+                    authIdOneTimeSecret: (_e = data.ppb) === null || _e === void 0 ? void 0 : _e.oneTimeSecret,
+                });
+            })
+                .catch(reject)
+                .then((result) => {
+                var _a;
+                this.log.info('PPB authentication result', result);
+                return session.fetchFromBackend('/v1/client/user/ppb/finish', {
+                    requestId: crypto.randomUUID(),
+                    operationId: (_a = data.ppb) === null || _a === void 0 ? void 0 : _a.operationId,
+                });
+            })
+                .then((response) => {
+                var _a, _b;
+                const ppbResponse = response;
+                if (ppbResponse.error) {
+                    const message = (_b = (_a = response.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : 'PPB authentication failed';
+                    callFinish(new Error(message)).then(() => reject(new auth_error_1.default(response.error.message, response.error.code, response.next, false)));
+                }
+                else {
+                    callFinish().then(() => resolve(ppbResponse.next));
+                }
+            })
+                .catch(reject);
+        });
+    }
+}
+class UserPpbEnrollStep extends UserPpbBaseStep {
+    constructor(enabled, startStep, finishStep) {
+        super(enabled, 'enroll', startStep, finishStep);
+        this.name = UserPpbEnrollStep.NAME;
+    }
+}
+UserPpbEnrollStep.NAME = 'user/ppb/register';
+exports.UserPpbEnrollStep = UserPpbEnrollStep;
+class UserPpbVerifyStep extends UserPpbBaseStep {
+    constructor(enabled, startStep, finishStep) {
+        super(enabled, 'verify', startStep, finishStep);
+        this.name = UserPpbVerifyStep.NAME;
+    }
+}
+UserPpbVerifyStep.NAME = 'user/ppb/verify';
+exports.UserPpbVerifyStep = UserPpbVerifyStep;

package/build/lib/proveauth/internal/user-present-step.js

@@ -9,9 +9,7 @@ class UserPresentStep {
         this.name = UserPresentStep.NAME;
     }
     execute(session) {
-        return new Promise((resolve, reject) => {
-            reject(new auth_error_1.default(`Step ${this.name} is not supported yet`));
-        });
+        return Promise.reject(new auth_error_1.default(`Step ${this.name} is not supported`));
     }
 }
 UserPresentStep.NAME = 'user/present';

package/build/lib/proveauth/internal/web-platform.d.ts

@@ -1,5 +1,5 @@
 import { AuthenticatorBuilder } from '@prove-identity/mobile-auth';
-import Platform, { AuthSessionIntegration, MessageChannel, RequestSigner } from './platform';
+import Platform, { AuthSessionIntegration, MessageChannel, PpbAuthOptions, PpbAuthResult, RequestSigner } from './platform';
 import WebDeviceAuth from './web-device-auth';
 import { Agent } from '@fingerprintjs/fingerprintjs-pro';
 export declare class WebSocketMessageChannel implements MessageChannel {
@@ -10,6 +10,7 @@ export declare class WebSocketMessageChannel implements MessageChannel {
     close(): void;
 }
 export declare class WebPlatform implements Platform {
+    private readonly log;
     private fpPromise;
     readonly webauthn: {
         getCredentials: (options?: CredentialRequestOptions) => Promise<CredentialType | null>;
@@ -22,6 +23,7 @@ export declare class WebPlatform implements Platform {
     fetch(input: string, init?: RequestInit): Promise<Response>;
     createMessageChannel(input: string): MessageChannel;
     createRequestSigner(session: AuthSessionIntegration): RequestSigner;
+    ppbAuthenticate(options: PpbAuthOptions): Promise<PpbAuthResult>;
     private getBrowserName;
     private getBrowserVersion;
     getOSName(): string;

package/build/lib/proveauth/internal/web-platform.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -6,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebPlatform = exports.WebSocketMessageChannel = void 0;
 const mobile_auth_1 = require("@prove-identity/mobile-auth");
 const platform_1 = require("./platform");
+const logger_1 = require("../common/logger");
 const request_signer_v3_1 = __importDefault(require("./request-signer-v3"));
 const web_device_auth_1 = __importDefault(require("./web-device-auth"));
 class WebSocketMessageChannel {
@@ -25,6 +35,7 @@ class WebSocketMessageChannel {
 exports.WebSocketMessageChannel = WebSocketMessageChannel;
 class WebPlatform {
     constructor() {
+        this.log = logger_1.LoggerFactory.getLogger('web-platform');
         this.webauthn = {
             getCredentials: (options) => {
                 return navigator.credentials.get(options);
@@ -53,6 +64,96 @@ class WebPlatform {
     createRequestSigner(session) {
         return new request_signer_v3_1.default(session);
     }
+    ppbAuthenticate(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const operationMap = new Map([
+                ['enroll', 'i'],
+                ['verify', 't'],
+            ]);
+            if (!options.authIdEndpointUrl) {
+                return Promise.reject('AuthID API endpoint URL is missing');
+            }
+            if (!options.authIdOperation) {
+                return Promise.reject('AuthID API operation is missing');
+            }
+            if (!operationMap.has(options.authIdOperation)) {
+                return Promise.reject('AuthID API operation is not recognized');
+            }
+            if (!options.authIdOperationId) {
+                return Promise.reject('AuthID operation ID is missing');
+            }
+            if (!options.authIdOneTimeSecret) {
+                return Promise.reject('AuthID operation secret is missing');
+            }
+            const componentName = 'authid-component';
+            try {
+                const authId = require('../external/@authid/web-component/authid-web-component');
+                if (!authId) {
+                    return Promise.reject('Failed to load PPB Auth web component');
+                }
+                if (!window.customElements.get(componentName)) {
+                    window.customElements.define(componentName, authId.AuthIDComponent);
+                }
+                yield window.customElements.whenDefined(componentName);
+            }
+            catch (e) {
+                this.log.error(e);
+                return Promise.reject(new Error('Failed to initialize PPB Auth web component'));
+            }
+            return new Promise((resolve, reject) => {
+                const existingComponent = document.querySelector(componentName);
+                if (existingComponent) {
+                    this.log.trace('Removing existing component', componentName);
+                    existingComponent.remove();
+                }
+                const authIdComponent = document.createElement(componentName);
+                const url = `${options.authIdEndpointUrl}/?` +
+                    `${operationMap.get(options.authIdOperation)}=${options.authIdOperationId}&` +
+                    `s=${options.authIdOneTimeSecret}`;
+                authIdComponent.setAttribute('data-url', url);
+                document.body.appendChild(authIdComponent);
+                const handleAuthDone = (success) => __awaiter(this, void 0, void 0, function* () {
+                    window.removeEventListener('message', handleMessage);
+                    this.log.trace('On PPB auth done');
+                    resolve({ authIdSuccess: success });
+                });
+                const handleMessage = (event) => {
+                    this.log.debug('PPB event', event.data);
+                    if (event.data.success) {
+                        const authIdComponent = document.querySelector(componentName);
+                        if (authIdComponent) {
+                            authIdComponent.remove();
+                        }
+                        handleAuthDone(true);
+                    }
+                    else {
+                        switch (event.data.pageName) {
+                            case 'documentFailedPage':
+                            case 'documentFailedNonMobilePage':
+                            case 'networkErrorPage':
+                            case 'livenessErrorPage':
+                            case 'docScanWasmTimeoutPage':
+                            case 'requestTimeoutPage':
+                            case 'transactionNotValidPage':
+                            case 'transactionMaxAttemptsPage':
+                            case 'QRCodePage':
+                                return;
+                            case 'verifiedMatchFailPage':
+                            case 'verifyDeclinedPage':
+                                authIdComponent.remove();
+                            case 'docScanResolutionTooLowPage':
+                            case 'videoDeviceNotFoundPage':
+                            case 'standardErrorPage':
+                            case 'defaultFailedPage':
+                                handleAuthDone(false);
+                                break;
+                        }
+                    }
+                };
+                window.addEventListener('message', handleMessage);
+            });
+        });
+    }
     getBrowserName() {
         const agent = navigator.userAgent;
         let browserName;

package/build/lib/proveauth/ppb.d.ts

@@ -0,0 +1,9 @@
+export type PpbOperation = 'enroll' | 'verify';
+export interface PpbStartStep {
+    execute: (operation: PpbOperation) => Promise<void>;
+}
+export interface PpbFinishStep {
+    execute: (operation: PpbOperation, error?: Error) => Promise<void>;
+}
+export type PpbStartStepFn = (operation: PpbOperation) => Promise<void>;
+export type PpbFinishStepFn = (operation: PpbOperation, error?: Error) => Promise<void>;

package/build/lib/proveauth/ppb.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/lib/proveauth/version.d.ts

@@ -1,3 +1,3 @@
-export declare const VERSION = "2.14.0";
-export declare const API_CONTRACT_VERSION = "2.14.0";
+export declare const VERSION = "2.15.1";
+export declare const API_CONTRACT_VERSION = "2.15.1";
 export declare const USER_AGENT_VERSIONS: string;

package/build/lib/proveauth/version.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.USER_AGENT_VERSIONS = exports.API_CONTRACT_VERSION = exports.VERSION = void 0;
-exports.VERSION = '2.14.0';
-exports.API_CONTRACT_VERSION = '2.14.0';
+exports.VERSION = '2.15.1';
+exports.API_CONTRACT_VERSION = '2.15.1';
 exports.USER_AGENT_VERSIONS = `ProveAuth/${exports.VERSION} Contract/${exports.API_CONTRACT_VERSION} WEB/1`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prove-identity/prove-auth",
-  "version": "2.14.0",
+  "version": "2.15.1",
   "description": "Prove Auth SDK for Web",
   "main": "build/lib/index.js",
   "files": [