@prove-identity/prove-auth 2.7.1 → 2.9.0

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

@@ -7,6 +7,7 @@ const logger_1 = require("../common/logger");
 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, getDeviceIp) {
@@ -44,39 +45,45 @@ class MobileInstantLinkStep extends auth_status_actions_1.AuthStatusActions {
                 this.startStep
                     .execute(phoneNumberNeeded, phoneValidationError)
                     .then((input) => {
-                    session
-                        .fetchFromBackend('/v1/client/mobile/instantlink/start', {
-                        sourceIp: this.getDeviceIp(),
-                        mobileNumber: input === null || input === void 0 ? void 0 : input.phoneNumber,
-                    })
-                        .then((response) => {
-                        var _a, _b, _c;
-                        const authResponse = response;
-                        if (authResponse.error) {
-                            reject(new auth_error_1.default(authResponse.error.message, authResponse.error.code, response.next, false));
-                        }
-                        else if (authResponse.data) {
-                            var errorMessage = '';
-                            if ((_a = authResponse.data) === null || _a === void 0 ? void 0 : _a.code) {
-                                errorMessage += `Error Code: ${authResponse.data.code}, `;
+                    const inputError = mobile_otp_step_1.default.validatePhoneNumberInput(input);
+                    if (inputError) {
+                        reject(inputError);
+                    }
+                    else {
+                        session
+                            .fetchFromBackend('/v1/client/mobile/instantlink/start', {
+                            sourceIp: this.getDeviceIp(),
+                            mobileNumber: input === null || input === void 0 ? void 0 : input.phoneNumber,
+                        })
+                            .then((response) => {
+                            var _a, _b, _c;
+                            const authResponse = response;
+                            if (authResponse.error) {
+                                reject(new auth_error_1.default(authResponse.error.message, authResponse.error.code, response.next, false));
                             }
-                            if ((_b = authResponse.data) === null || _b === void 0 ? void 0 : _b.message) {
-                                errorMessage += `${authResponse.data.message}`;
+                            else if (authResponse.data) {
+                                var errorMessage = '';
+                                if ((_a = authResponse.data) === null || _a === void 0 ? void 0 : _a.code) {
+                                    errorMessage += `Error Code: ${authResponse.data.code}, `;
+                                }
+                                if ((_b = authResponse.data) === null || _b === void 0 ? void 0 : _b.message) {
+                                    errorMessage += `${authResponse.data.message}`;
+                                }
+                                else {
+                                    errorMessage += `Error validating phone number`;
+                                }
+                                let phoneNumberValidationError = new phone_number_input_1.PhoneValidationError(errorMessage, (_c = authResponse.data) === null || _c === void 0 ? void 0 : _c.code);
+                                this.log.error(`Server reports invalid phone number: ${errorMessage}`);
+                                this.runStartStep(session, phoneNumberNeeded, phoneNumberValidationError)
+                                    .then(resolve)
+                                    .catch(reject);
                             }
                             else {
-                                errorMessage += `Error validating phone number`;
+                                resolve(authResponse.next);
                             }
-                            let phoneNumberValidationError = new phone_number_input_1.PhoneValidationError(errorMessage, (_c = authResponse.data) === null || _c === void 0 ? void 0 : _c.code);
-                            this.log.error(`Server reports invalid phone number: ${errorMessage}`);
-                            this.runStartStep(session, phoneNumberNeeded, phoneNumberValidationError)
-                                .then(resolve)
-                                .catch(reject);
-                        }
-                        else {
-                            resolve(authResponse.next);
-                        }
-                    })
-                        .catch(reject);
+                        })
+                            .catch(reject);
+                    }
                 })
                     .catch(reject);
             }

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

@@ -1,5 +1,6 @@
 import AuthSession from './auth-session';
 import AuthStep from './auth-step';
+import AuthError from './auth-error';
 import { OtpStartStep, OtpFinishStep } from '../otp';
 export default class MobileOtpStep implements AuthStep {
     static readonly NAME = "mobile/otp";
@@ -9,6 +10,8 @@ export default class MobileOtpStep implements AuthStep {
     private otpFinishStep?;
     constructor(otpStartStep?: OtpStartStep, otpFinishStep?: OtpFinishStep);
     execute(session: AuthSession): Promise<string>;
+    static validatePhoneNumberInput(input: any): AuthError | undefined;
     private runOtpStartStep;
+    static validateFinishResult(result: any): AuthError | undefined;
     private runOtpFinishStep;
 }

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

@@ -34,45 +34,66 @@ class MobileOtpStep {
                 .catch(reject);
         });
     }
+    static validatePhoneNumberInput(input) {
+        if (input === null || input === undefined) {
+            return;
+        }
+        if (typeof input !== 'object') {
+            return new auth_error_1.default('Input must be an object');
+        }
+        if (!('phoneNumber' in input)) {
+            return new auth_error_1.default('phoneNumber field in the input is missing');
+        }
+        if (typeof input.phoneNumber !== 'string') {
+            return new auth_error_1.default('phoneNumber field in the input must be a string');
+        }
+        return;
+    }
     runOtpStartStep(session, otpStartStep, otpFinishStep, phoneNumberNeeded, phoneValidationError) {
         return new Promise((resolve, reject) => {
             otpStartStep
                 .execute(phoneNumberNeeded, phoneValidationError)
                 .then((input) => {
-                session
-                    .fetchFromBackend('/v1/client/mobile/otp/start', {
-                    mobileNumber: input === null || input === void 0 ? void 0 : input.phoneNumber,
-                })
-                    .then((response) => {
-                    const authResponse = response;
-                    if (authResponse.error) {
-                        reject(new auth_error_1.default(authResponse.error.message, authResponse.error.code, response.next, false));
-                    }
-                    else if (authResponse.data) {
-                        let data = authResponse.data;
-                        var errorMessage = '';
-                        if (data === null || data === void 0 ? void 0 : data.code) {
-                            errorMessage += `Error Code: ${data.code}, `;
+                const inputError = MobileOtpStep.validatePhoneNumberInput(input);
+                if (inputError) {
+                    reject(inputError);
+                }
+                else {
+                    session
+                        .fetchFromBackend('/v1/client/mobile/otp/start', {
+                        mobileNumber: input === null || input === void 0 ? void 0 : input.phoneNumber,
+                    })
+                        .then((response) => {
+                        const authResponse = response;
+                        if (authResponse.error) {
+                            reject(new auth_error_1.default(authResponse.error.message, authResponse.error.code, response.next, false));
                         }
-                        if (data === null || data === void 0 ? void 0 : data.message) {
-                            errorMessage += `${data.message}`;
+                        else if (authResponse.data) {
+                            let data = authResponse.data;
+                            var errorMessage = '';
+                            if (data === null || data === void 0 ? void 0 : data.code) {
+                                errorMessage += `Error Code: ${data.code}, `;
+                            }
+                            if (data === null || data === void 0 ? void 0 : data.message) {
+                                errorMessage += `${data.message}`;
+                            }
+                            else {
+                                errorMessage += `Error validating phone number`;
+                            }
+                            let phoneNumberValidationError = new phone_number_input_1.PhoneValidationError(errorMessage, data === null || data === void 0 ? void 0 : data.code);
+                            this.log.error(`Server reports invalid phone number: ${errorMessage}`);
+                            this.runOtpStartStep(session, otpStartStep, otpFinishStep, phoneNumberNeeded, phoneNumberValidationError)
+                                .then(resolve)
+                                .catch(reject);
                         }
                         else {
-                            errorMessage += `Error validating phone number`;
+                            this.runOtpFinishStep(session, otpStartStep, otpFinishStep, phoneNumberNeeded)
+                                .then(resolve)
+                                .catch(reject);
                         }
-                        let phoneNumberValidationError = new phone_number_input_1.PhoneValidationError(errorMessage, data === null || data === void 0 ? void 0 : data.code);
-                        this.log.error(`Server reports invalid phone number: ${errorMessage}`);
-                        this.runOtpStartStep(session, otpStartStep, otpFinishStep, phoneNumberNeeded, phoneNumberValidationError)
-                            .then(resolve)
-                            .catch(reject);
-                    }
-                    else {
-                        this.runOtpFinishStep(session, otpStartStep, otpFinishStep, phoneNumberNeeded)
-                            .then(resolve)
-                            .catch(reject);
-                    }
-                })
-                    .catch(reject);
+                    })
+                        .catch(reject);
+                }
             })
                 .catch((error) => {
                 const message = auth_error_1.default.extractMessage(error);
@@ -80,6 +101,27 @@ class MobileOtpStep {
             });
         });
     }
+    static validateFinishResult(result) {
+        if (result === null || result === undefined || typeof result !== 'object') {
+            return new auth_error_1.default('result should be a valid object');
+        }
+        else if (!('resultType' in result)) {
+            return new auth_error_1.default('resultType field in the result is missing');
+        }
+        else if (result.resultType === otp_1.OtpFinishResultType.OnSuccess) {
+            const input = result.input;
+            if (input === null || input === undefined || typeof input !== 'object') {
+                return new auth_error_1.default('input should be a valid object when resultType field is set with OnSuccess value');
+            }
+            if (!('otp' in input)) {
+                return new auth_error_1.default('otp field in the input is missing');
+            }
+            if (typeof input.otp !== 'string') {
+                return new auth_error_1.default('otp field in the input must be a string');
+            }
+        }
+        return;
+    }
     runOtpFinishStep(session, otpStartStep, otpFinishStep, phoneNumberNeeded, otpError) {
         return new Promise((resolve, reject) => {
             otpFinishStep
@@ -87,47 +129,53 @@ class MobileOtpStep {
                 .then((otpFinishResult) => {
                 var _a;
                 let result = otpFinishResult;
-                switch (result.resultType) {
-                    case otp_1.OtpFinishResultType.OnResendOtp:
-                        this.runOtpStartStep(session, otpStartStep, otpFinishStep, phoneNumberNeeded)
-                            .then(resolve)
-                            .catch(reject);
-                        break;
-                    case otp_1.OtpFinishResultType.OnSuccess:
-                        let input = result.input;
-                        session
-                            .fetchFromBackend('/v1/client/mobile/otp/finish', {
-                            otp: (_a = input === null || input === void 0 ? void 0 : input.otp) !== null && _a !== void 0 ? _a : '',
-                        })
-                            .then((response) => {
-                            const authResponse = response;
-                            if (authResponse.error) {
-                                reject(new auth_error_1.default(authResponse.error.message, authResponse.error.code, response.next, false));
-                            }
-                            else if (authResponse.data) {
-                                let data = authResponse.data;
-                                var errorMessage = '';
-                                if (data === null || data === void 0 ? void 0 : data.code) {
-                                    errorMessage += `Error Code: ${data.code}, `;
+                const resultError = MobileOtpStep.validateFinishResult(result);
+                if (resultError) {
+                    reject(resultError);
+                }
+                else {
+                    switch (result.resultType) {
+                        case otp_1.OtpFinishResultType.OnResendOtp:
+                            this.runOtpStartStep(session, otpStartStep, otpFinishStep, phoneNumberNeeded)
+                                .then(resolve)
+                                .catch(reject);
+                            break;
+                        case otp_1.OtpFinishResultType.OnSuccess:
+                            let input = result.input;
+                            session
+                                .fetchFromBackend('/v1/client/mobile/otp/finish', {
+                                otp: (_a = input === null || input === void 0 ? void 0 : input.otp) !== null && _a !== void 0 ? _a : '',
+                            })
+                                .then((response) => {
+                                const authResponse = response;
+                                if (authResponse.error) {
+                                    reject(new auth_error_1.default(authResponse.error.message, authResponse.error.code, response.next, false));
                                 }
-                                if (data === null || data === void 0 ? void 0 : data.message) {
-                                    errorMessage += `${data.message}`;
+                                else if (authResponse.data) {
+                                    let data = authResponse.data;
+                                    var errorMessage = '';
+                                    if (data === null || data === void 0 ? void 0 : data.code) {
+                                        errorMessage += `Error Code: ${data.code}, `;
+                                    }
+                                    if (data === null || data === void 0 ? void 0 : data.message) {
+                                        errorMessage += `${data.message}`;
+                                    }
+                                    else {
+                                        errorMessage += `Error validating OTP`;
+                                    }
+                                    let 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)
+                                        .catch(reject);
                                 }
                                 else {
-                                    errorMessage += `Error validating OTP`;
+                                    resolve(response.next);
                                 }
-                                let 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)
-                                    .catch(reject);
-                            }
-                            else {
-                                resolve(response.next);
-                            }
-                        })
-                            .catch(reject);
-                        break;
+                            })
+                                .catch(reject);
+                            break;
+                    }
                 }
             })
                 .catch((error) => {

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 DarwiniumResult from '../darwinium-result';
 export declare const DEVICE_CAPABILITY_WEBAUTHN = "webauthn";
 export interface MessageChannel {
     addEventListener: (type: string, listener: (event: any) => void) => void;
@@ -43,6 +44,7 @@ export default interface Platform {
     getFpPromise: () => Promise<Agent> | undefined;
     setFpPromise: (fpPromise: Promise<Agent>) => void;
     getOrigin: () => string;
+    collectDarwiniumData: (iFrameEnabled: boolean, iFrameSrc?: string) => Promise<DarwiniumResult>;
 }
 export declare function stringToArrayBuffer(input: string): ArrayBuffer;
 export declare function arrayBufferToString(input: ArrayBuffer): string;

package/build/lib/proveauth/internal/report-error-step.d.ts

@@ -1,7 +1,7 @@
 import AuthSession from './auth-session';
 import AuthStep from './auth-step';
 export default class ReportErrorStep implements AuthStep {
-    private static readonly errorMap;
+    private static readonly endpointMap;
     private readonly logger;
     private _message;
     private _code?;
@@ -12,5 +12,4 @@ export default class ReportErrorStep implements AuthStep {
     get code(): number | undefined;
     get message(): string;
     execute(session: AuthSession): Promise<string>;
-    private lookupError;
 }

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

@@ -14,6 +14,7 @@ const mobile_instant_step_1 = __importDefault(require("./mobile-instant-step"));
 const mobile_instantlink_step_1 = __importDefault(require("./mobile-instantlink-step"));
 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");
 class ReportErrorStep {
     constructor(error) {
@@ -53,34 +54,34 @@ class ReportErrorStep {
         if (this.nextStep === main_authenticator_1.default.AUTH_DONE) {
             return Promise.resolve(main_authenticator_1.default.AUTH_DONE);
         }
-        else if (!this.nextStep || this.reportable) {
+        const endpoint = session.lastStep
+            ? ReportErrorStep.endpointMap.get(session.lastStep)
+            : undefined;
+        if (endpoint && (this.reportable || !this.nextStep)) {
             return new Promise((resolve, reject) => {
-                const error = this.lookupError(session.lastStep);
                 session
-                    .fetchFromBackend(`/v1/client/${error}/error`, {
+                    .fetchFromBackend(`/v1/client/${endpoint}/error`, {
                     code: this._code ? this._code : undefined,
                     message: this._message,
                 })
-                    .then((response) => {
-                    resolve(response.next);
-                })
+                    .then((response) => resolve(response.next))
                     .catch(reject);
             });
         }
-        else {
+        else if (this.nextStep) {
             return Promise.resolve(this.nextStep);
         }
-    }
-    lookupError(last) {
-        const defaultKind = 'device/passive';
-        return last ? ReportErrorStep.errorMap.get(last) || defaultKind : defaultKind;
+        else {
+            return Promise.reject(new auth_error_1.default('Cannot determine the next auth step'));
+        }
     }
 }
-ReportErrorStep.errorMap = new Map([
+ReportErrorStep.endpointMap = new Map([
     [device_passive_step_1.default.NAME, 'device/passive'],
     [device_passive_silent_step_1.default.NAME, 'device/passive'],
     [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'],
     [mobile_instant_step_1.default.NAME, 'mobile/instant'],
     [mobile_instantlink_step_1.default.NAME, 'mobile/instantlink'],
     [mobile_otp_step_1.default.NAME, 'mobile/otp'],

package/build/lib/proveauth/internal/scan-message-step.js

@@ -29,7 +29,7 @@ class ScanMessageStep {
                     })
                         .then((response) => {
                         if (response.error) {
-                            reject(new auth_error_1.default(response.error.message, response.error.code, response.next));
+                            reject(new auth_error_1.default(response.error.message, response.error.code, response.next, false));
                         }
                         else {
                             resolve(response.next);

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

@@ -1,8 +1,10 @@
+import DarwiniumResult from '../darwinium-result';
 export default class Settings {
     static readonly KEY_PREFIX = "ProveAuth";
     static readonly DEVICE_ID_KEY = "DeviceId";
     static readonly NAMESPACE_KEY = "namespace";
     static readonly FIDO_PASSKEY_REGISTERED_KEY = "fidoPasskeyRegistered";
+    static readonly DARWINIUM_RESULT_KEY = "DarwiniumResult";
     private readonly log;
     private storage;
     upkEnabled: boolean;
@@ -14,6 +16,8 @@ export default class Settings {
     set fidoPasskeyRegistered(val: boolean);
     get namespace(): string | null;
     set namespace(val: string | null);
+    get darwiniumResult(): DarwiniumResult | undefined;
+    set darwiniumResult(result: DarwiniumResult | undefined);
     private getKey;
     private setOrRemove;
 }

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

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const logger_1 = require("../common/logger");
+const darwinium_result_1 = __importDefault(require("../darwinium-result"));
 class Settings {
     constructor(storage) {
         this.log = logger_1.LoggerFactory.getLogger('settings');
@@ -12,6 +16,7 @@ class Settings {
         this.deviceId = null;
         this.namespace = null;
         this.fidoPasskeyRegistered = false;
+        this.darwiniumResult = undefined;
     }
     get deviceId() {
         return this.storage.getItem(this.getKey(Settings.DEVICE_ID_KEY));
@@ -32,6 +37,16 @@ class Settings {
         this.log.trace('namespace set to ' + val);
         this.setOrRemove(Settings.NAMESPACE_KEY, val);
     }
+    get darwiniumResult() {
+        let resultJson = this.storage.getItem(this.getKey(Settings.DARWINIUM_RESULT_KEY));
+        if (resultJson) {
+            const parsed = JSON.parse(resultJson);
+            return Object.assign(new darwinium_result_1.default(), parsed);
+        }
+    }
+    set darwiniumResult(result) {
+        this.setOrRemove(Settings.DARWINIUM_RESULT_KEY, JSON.stringify(result));
+    }
     getKey(key) {
         return `${Settings.KEY_PREFIX}.${key}`;
     }
@@ -48,4 +63,5 @@ Settings.KEY_PREFIX = 'ProveAuth';
 Settings.DEVICE_ID_KEY = 'DeviceId';
 Settings.NAMESPACE_KEY = 'namespace';
 Settings.FIDO_PASSKEY_REGISTERED_KEY = 'fidoPasskeyRegistered';
+Settings.DARWINIUM_RESULT_KEY = 'DarwiniumResult';
 exports.default = Settings;

package/build/lib/proveauth/internal/web-device-auth.d.ts

@@ -4,6 +4,7 @@ export declare class WebDeviceRegistration implements DeviceRegistration {
     private keys?;
     deviceId: string | null;
     fingerprint?: Signal;
+    darwinium?: Signal;
     readonly namespace: string;
     readonly keyId: string;
     readonly algorithm: string;
@@ -14,7 +15,8 @@ export declare class WebDeviceRegistration implements DeviceRegistration {
     sign(data: string): Promise<string>;
     getPublicKey(): Promise<string>;
     getAuthRegistration(challenge: string): Promise<AuthRegistration>;
-    getSignals(): Signals | undefined;
+    getSignals(): Signals;
+    setDarwiniumSignal(dwnSignal: Signal): void;
     private initialize;
     private p1363ToDer;
     private lenVal;

package/build/lib/proveauth/internal/web-device-auth.js

@@ -84,7 +84,13 @@ class WebDeviceRegistration {
         });
     }
     getSignals() {
-        return this.fingerprint ? { fingerprint: this.fingerprint } : undefined;
+        return {
+            fingerprint: this.fingerprint,
+            darwinium: this.darwinium,
+        };
+    }
+    setDarwiniumSignal(dwnSignal) {
+        this.darwinium = dwnSignal;
     }
     initialize() {
         return new Promise((resolve, reject) => {
@@ -149,11 +155,15 @@ class WebDeviceAuth {
                 reject('Failed to open registration database: ' + e);
             };
             openReq.onsuccess = (e) => {
-                const db = openReq.result;
+                const db = e.target.result;
                 const tx = db.transaction([WebDeviceAuth.DB_STORE], 'readonly');
                 tx.oncomplete = () => db.close();
                 const store = tx.objectStore(WebDeviceAuth.DB_STORE);
                 const getReq = store.get(namespace);
+                getReq.onerror = (e) => {
+                    this.log.error(e);
+                    reject(new Error('Failed to access registration'));
+                };
                 getReq.onsuccess = () => {
                     if (getReq.result) {
                         resolve(new WebDeviceRegistration(getReq.result));
@@ -162,9 +172,6 @@ class WebDeviceAuth {
                         resolve(null);
                     }
                 };
-                getReq.onerror = (e) => {
-                    reject(new Error('Failed to access registration'));
-                };
             };
         });
     }
@@ -175,7 +182,7 @@ class WebDeviceAuth {
                 reject('Failed to open registration database: ' + e);
             };
             openReq.onsuccess = (e) => {
-                const db = openReq.result;
+                const db = e.target.result;
                 const tx = db.transaction([WebDeviceAuth.DB_STORE], 'readwrite');
                 tx.oncomplete = () => db.close();
                 const store = tx.objectStore(WebDeviceAuth.DB_STORE);
@@ -183,11 +190,12 @@ class WebDeviceAuth {
                 const addReq = store.put(registration);
                 addReq.onsuccess = () => {
                     this.log.trace('Registration saved');
+                    resolve();
                 };
                 addReq.onerror = (e) => {
+                    this.log.error(e);
                     reject(new auth_error_1.default('Failed to store registration'));
                 };
-                resolve();
             };
         });
     }
@@ -198,7 +206,7 @@ class WebDeviceAuth {
                 reject('Failed to open registration database: ' + e);
             };
             openReq.onsuccess = (e) => {
-                var db = openReq.result;
+                var db = e.target.result;
                 var tx = db.transaction([WebDeviceAuth.DB_STORE], 'readwrite');
                 tx.oncomplete = () => db.close();
                 if (!db.objectStoreNames.contains(WebDeviceAuth.DB_STORE)) {
@@ -212,6 +220,7 @@ class WebDeviceAuth {
                     resolve();
                 };
                 delReq.onerror = (e) => {
+                    this.log.error(e);
                     reject(new Error('Failed to delete registration'));
                 };
             };
@@ -224,7 +233,8 @@ class WebDeviceAuth {
                 resolve();
             };
             delReq.onerror = (e) => {
-                this.log.warn('Failed to delete registration database: ' + e);
+                this.log.warn('Failed to delete registration database');
+                this.log.warn(e);
                 resolve();
             };
         });
@@ -232,12 +242,18 @@ class WebDeviceAuth {
     openDatabase() {
         const openReq = this.dbFactory.open(WebDeviceAuth.DB_NAME, WebDeviceAuth.DB_VERSION);
         openReq.onupgradeneeded = (e) => {
-            const db = openReq.result;
-            this.log.debug('Registration not found, database is missing, initializing');
-            const store = db.createObjectStore(WebDeviceAuth.DB_STORE, { keyPath: 'namespace' });
-            store.transaction.oncomplete = (e) => {
-                this.log.trace('Store initialization completed');
-            };
+            var _a;
+            const db = (_a = e.target) === null || _a === void 0 ? void 0 : _a.result;
+            if (db) {
+                this.log.debug('Registration not found, database is missing, initializing');
+                const store = db.createObjectStore(WebDeviceAuth.DB_STORE, { keyPath: 'namespace' });
+                store.transaction.oncomplete = (e) => {
+                    this.log.trace('Store initialization completed');
+                };
+            }
+            else {
+                this.log.error('Failed to initialize registration database: database is null');
+            }
         };
         return openReq;
     }

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

@@ -1,8 +1,8 @@
-/// <reference types="webappsec-credential-management" />
 import { AuthenticatorBuilder } from '@prove-identity/mobile-auth';
 import Platform, { AuthSessionIntegration, MessageChannel, RequestSigner } from './platform';
 import WebDeviceAuth from './web-device-auth';
 import { Agent } from '@fingerprintjs/fingerprintjs-pro';
+import DarwiniumResult from '../darwinium-result';
 export declare class WebSocketMessageChannel implements MessageChannel {
     private readonly webSocket;
     constructor(endpointUrl: string);
@@ -33,4 +33,5 @@ export declare class WebPlatform implements Platform {
     getFpPromise(): Promise<Agent> | undefined;
     setFpPromise(fpPromise: Promise<Agent>): void;
     getOrigin(): string;
+    collectDarwiniumData(iFrameEnabled: boolean, iFrameSrc?: string): Promise<DarwiniumResult>;
 }