@prove-identity/prove-auth 2.13.1 → 2.15.1

package/build/lib/proveauth/internal/device-passive-verify-step.js

@@ -18,25 +18,10 @@ class DevicePassiveVerifyStep {
     }
     static runFidoVerify(log, session) {
         return new Promise((resolve, reject) => {
-            session
-                .getFingerprintData()
-                .then((signal) => {
-                const signals = { fingerprint: signal };
-                DevicePassiveVerifyStep.makeFidoVerifyFinishRequest(log, session, signals)
-                    .then(resolve)
-                    .catch(reject);
-            })
-                .catch((error) => {
-                const errorMsg = `Unexpected error happened during Fingerprint data collection ${error.toString}`;
-                log.warn(errorMsg);
-                const signals = { fingerprint: { error: errorMsg } };
-                DevicePassiveVerifyStep.makeFidoVerifyFinishRequest(log, session, signals)
-                    .then(resolve)
-                    .catch(reject);
-            });
+            DevicePassiveVerifyStep.makeFidoVerifyFinishRequest(log, session).then(resolve).catch(reject);
         });
     }
-    static makeFidoVerifyFinishRequest(log, session, signals) {
+    static makeFidoVerifyFinishRequest(log, session) {
         return new Promise((resolve, reject) => {
             const credential = session.credential;
             const assertion = credential.response;
@@ -55,7 +40,6 @@ class DevicePassiveVerifyStep {
                             : undefined,
                     },
                 },
-                signals: signals,
             })
                 .then((response) => {
                 if (response.error) {

package/build/lib/proveauth/internal/main-authenticator.js

@@ -138,6 +138,9 @@ class MainAuthenticator {
         session.lastStep = step;
         return new Promise((resolve, reject) => {
             if ([MainAuthenticator.AUTH_DONE, MainAuthenticator.AUTH_EMPTY].includes(step)) {
+                if (!session.settings.deviceId && session.settings.fingerPrintTimestamp) {
+                    session.resetFptts();
+                }
                 resolve();
             }
             else if (attempt > MainAuthenticator.MAX_ATTEMPTS) {

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

@@ -56,15 +56,15 @@ class MobileInstantStep {
                         implementation: this.implementation,
                     })
                         .then((response) => {
-                        var _a;
                         if (response.error) {
                             this.nextBak = response.next;
                             this.errorCodeBak = response.error.code;
                             reject(new auth_error_1.default(response.error.message, response.error.code, response.next, false));
                         }
                         else {
+                            const data = response.data;
                             resolve({
-                                authUrl: (_a = response.data) === null || _a === void 0 ? void 0 : _a.redirectUrl,
+                                authUrl: data ? data.redirectUrl : undefined,
                             });
                         }
                     })

package/build/lib/proveauth/internal/mobile-instantlink-step.d.ts

@@ -10,10 +10,7 @@ export default class MobileInstantLinkStep extends AuthStatusActions implements
     private readonly retryStep?;
     private readonly getDeviceIp;
     constructor(startStep?: InstantLinkStartStep, retryStep?: InstantLinkRetryStep, getDeviceIp?: () => string | null);
-    private isTestMode;
     execute(session: AuthSession): Promise<string>;
-    private getInstantLinkError;
     private runStartStep;
     private runRetryStep;
-    private handleTestMode;
 }

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/settings.d.ts

@@ -3,6 +3,7 @@ export default class Settings {
     static readonly DEVICE_ID_KEY = "DeviceId";
     static readonly NAMESPACE_KEY = "namespace";
     static readonly FIDO_PASSKEY_REGISTERED_KEY = "fidoPasskeyRegistered";
+    static readonly FP_TIMESTAMPT = "fingerPrintTimestamp";
     private readonly log;
     private storage;
     upkEnabled: boolean;
@@ -11,6 +12,8 @@ export default class Settings {
     get deviceId(): string | null;
     set deviceId(val: string | null);
     get fidoPasskeyRegistered(): boolean;
+    set fingerPrintTimestamp(val: number | null);
+    get fingerPrintTimestamp(): number | null;
     set fidoPasskeyRegistered(val: boolean);
     get namespace(): string | null;
     set namespace(val: string | null);

package/build/lib/proveauth/internal/settings.js

@@ -12,6 +12,7 @@ class Settings {
         this.deviceId = null;
         this.namespace = null;
         this.fidoPasskeyRegistered = false;
+        this.fingerPrintTimestamp = null;
     }
     get deviceId() {
         return this.storage.getItem(this.getKey(Settings.DEVICE_ID_KEY));
@@ -22,6 +23,18 @@ class Settings {
     get fidoPasskeyRegistered() {
         return this.storage.getItem(this.getKey(Settings.FIDO_PASSKEY_REGISTERED_KEY)) === 'true';
     }
+    set fingerPrintTimestamp(val) {
+        const assignedValue = val !== null ? val.toString() : null;
+        this.setOrRemove(Settings.FP_TIMESTAMPT, assignedValue);
+    }
+    get fingerPrintTimestamp() {
+        const storedTimestampString = this.storage.getItem(this.getKey(Settings.FP_TIMESTAMPT));
+        if (!storedTimestampString) {
+            return null;
+        }
+        let fingerprintTimestamp = parseInt(storedTimestampString);
+        return isNaN(fingerprintTimestamp) ? null : fingerprintTimestamp;
+    }
     set fidoPasskeyRegistered(val) {
         this.setOrRemove(Settings.FIDO_PASSKEY_REGISTERED_KEY, val ? 'true' : null);
     }
@@ -48,4 +61,5 @@ Settings.KEY_PREFIX = 'ProveAuth';
 Settings.DEVICE_ID_KEY = 'DeviceId';
 Settings.NAMESPACE_KEY = 'namespace';
 Settings.FIDO_PASSKEY_REGISTERED_KEY = 'fidoPasskeyRegistered';
+Settings.FP_TIMESTAMPT = 'fingerPrintTimestamp';
 exports.default = Settings;

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;