@prove-identity/prove-auth 2.10.1 → 2.14.0

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

@@ -1,4 +1,18 @@
-import PhoneNumberInput, { PhoneNumberStep, PhoneNumberStepFn } from './internal/phone-number-input';
+import AuthError from './internal/auth-error';
+import PhoneNumberInput, { PhoneValidationError } from './internal/phone-number-input';
+export declare class InstantLinkMaxRetryError extends AuthError {
+    constructor(message?: string, code?: number);
+}
+export interface InstantLinkStartStep {
+    execute: (phoneNumberNeeded: boolean, instantLinkError?: PhoneValidationError) => Promise<PhoneNumberInput | null>;
+}
+export type InstantLinkStartStepFn = (phoneNumberNeeded: boolean, instantLinkError?: PhoneValidationError) => Promise<PhoneNumberInput | null>;
+export declare enum InstantLinkResultType {
+    OnResend = 0,
+    OnMobileNumberChange = 1
+}
+export interface InstantLinkRetryStep {
+    execute: (instantLinkError?: InstantLinkMaxRetryError) => Promise<InstantLinkResultType>;
+}
+export type InstantLinkRetryStepFn = (instantLinkError?: InstantLinkMaxRetryError) => Promise<InstantLinkResultType>;
 export type InstantLinkStartInput = PhoneNumberInput;
-export type InstantLinkStartStep = PhoneNumberStep;
-export type InstantLinkStartStepFn = PhoneNumberStepFn;

package/build/lib/proveauth/instantlink.js

@@ -1,2 +1,18 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstantLinkResultType = exports.InstantLinkMaxRetryError = void 0;
+const auth_error_1 = __importDefault(require("./internal/auth-error"));
+class InstantLinkMaxRetryError extends auth_error_1.default {
+    constructor(message, code) {
+        super(message, code);
+    }
+}
+exports.InstantLinkMaxRetryError = InstantLinkMaxRetryError;
+var InstantLinkResultType;
+(function (InstantLinkResultType) {
+    InstantLinkResultType[InstantLinkResultType["OnResend"] = 0] = "OnResend";
+    InstantLinkResultType[InstantLinkResultType["OnMobileNumberChange"] = 1] = "OnMobileNumberChange";
+})(InstantLinkResultType = exports.InstantLinkResultType || (exports.InstantLinkResultType = {}));

package/build/lib/proveauth/internal/auth-request.d.ts

@@ -33,7 +33,6 @@ export interface V1ClientDeviceFido2RegisterFinish {
     deviceName: string;
     deviceCapabilities: string[];
     registrations: AuthRegistration[];
-    signals?: Signals;
 }
 export interface V1ClientDeviceFido2VerifyStart {
     deviceId: string;
@@ -52,7 +51,6 @@ export interface WebAuthnAssertion {
 }
 export interface V1ClientDeviceFido2VerifyFinish {
     webAuthnAssertion: WebAuthnAssertion;
-    signals?: Signals;
 }
 export interface V1ClientDevicePassiveRegister {
     deviceName: string;

package/build/lib/proveauth/internal/auth-session.d.ts

@@ -32,7 +32,11 @@ export default class AuthSession implements AuthSessionIntegration {
     closeAllMessageChannels(): void;
     getDeviceRegistration(): Promise<DeviceRegistration | null>;
     embedFpResultToDeviceRegistration(registration: DeviceRegistration): Promise<DeviceRegistration>;
+    private getCurrentTimestampInSeconds;
+    markNewFptts(ts?: number): void;
+    resetFptts(): void;
     getFingerprintData(): Promise<Signal | undefined>;
     shouldCollectFP(): boolean;
+    shouldRefreshFpSignal(currentTimestamp: number): boolean;
     private parseJwt;
 }

package/build/lib/proveauth/internal/auth-session.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const logger_1 = require("../common/logger");
 const version_1 = require("../version");
+const auth_error_1 = __importDefault(require("./auth-error"));
 const auth_token_claims_1 = require("./auth-token-claims");
 const error_code_1 = __importDefault(require("./error-code"));
 const web_socket_close_reasons_1 = require("./web-socket-close-reasons");
@@ -164,8 +165,7 @@ class AuthSession {
             onClose(reason, code);
         });
         channel.addEventListener('error', (event) => {
-            this.log.debug('Message channel encountered an error');
-            this.log.debug(event);
+            this.log.debug('Message channel encountered an error', event);
         });
         channel.addEventListener('message', (event) => {
             this.log.trace('Message channel received a message');
@@ -227,17 +227,28 @@ class AuthSession {
                 resolve(registration);
             })
                 .catch((error) => {
-                const errorMsg = `Unexpected error happened during Fingerprint data collection: ${error.toString}`;
-                this.log.warn(errorMsg);
+                const errorMsg = `Unexpected error happened during Fingerprint data collection: ${auth_error_1.default.extractMessage(error)}`;
+                this.log.warn(error);
                 registration.setFpSignal({ error: errorMsg });
             });
         });
     }
+    getCurrentTimestampInSeconds() {
+        const currentTimestampMs = Date.now();
+        const currentTimestampSeconds = Math.floor(currentTimestampMs / 1000);
+        return currentTimestampSeconds;
+    }
+    markNewFptts(ts) {
+        this.settings.fingerPrintTimestamp = ts ? ts : this.getCurrentTimestampInSeconds();
+    }
+    resetFptts() {
+        this.settings.fingerPrintTimestamp = null;
+    }
     getFingerprintData() {
         return new Promise((resolve) => {
             var fpPromise = this.platform.getFpPromise();
             if (!this.shouldCollectFP()) {
-                this.log.debug('Fingerprint is not enabled from AuthToken');
+                this.log.trace('Fingerprint is not enabled from AuthToken');
                 resolve(undefined);
             }
             else if (!fpPromise) {
@@ -245,7 +256,12 @@ class AuthSession {
                 this.log.warn(msg);
                 resolve({ error: msg });
             }
+            else if (!this.shouldRefreshFpSignal(this.getCurrentTimestampInSeconds())) {
+                this.log.trace('Existing FP signal is not yet expired, skip new collection');
+                resolve(undefined);
+            }
             else {
+                this.log.trace('Collect new FP signal');
                 fpPromise
                     .then((fp) => fp.get())
                     .then((result) => {
@@ -260,8 +276,8 @@ class AuthSession {
                     }
                 })
                     .catch((error) => {
-                    const msg = `Error in collecting Fingerprint data: ${error.toString}`;
-                    this.log.warn(msg);
+                    const msg = `Error in collecting Fingerprint data: ${auth_error_1.default.extractMessage(error)}`;
+                    this.log.warn(error);
                     resolve({ error: msg });
                 });
             }
@@ -274,6 +290,16 @@ class AuthSession {
         }
         return false;
     }
+    shouldRefreshFpSignal(currentTimestamp) {
+        var _a, _b, _c, _d;
+        if (!this.settings.deviceId || !this.settings.fingerPrintTimestamp) {
+            this.resetFptts();
+            return true;
+        }
+        const refreshRate = (_d = (_c = (_b = (_a = this.claims) === null || _a === void 0 ? void 0 : _a.auth.subs.dev) === null || _b === void 0 ? void 0 : _b.sgnls) === null || _c === void 0 ? void 0 : _c.fptrr) !== null && _d !== void 0 ? _d : 0;
+        const interval = currentTimestamp - this.settings.fingerPrintTimestamp;
+        return interval >= refreshRate;
+    }
     parseJwt(token) {
         return JSON.parse(atob(token.split('.')[1]));
     }

package/build/lib/proveauth/internal/auth-token-claims.d.ts

@@ -11,6 +11,7 @@ export interface InstantAuthenticator {
 }
 export interface InstantLinkAuthenticator {
     mnp: boolean;
+    amnrp?: boolean;
     tme?: boolean;
 }
 export interface OtpAuthenticator {
@@ -29,6 +30,7 @@ export interface Authenticators {
 }
 export interface Signals {
     fpt?: boolean;
+    fptrr?: number;
     dwn?: boolean;
 }
 export interface DeviceAuthSubjectClaim {

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

@@ -23,11 +23,9 @@ class DevicePassiveRegisterStep {
                     .getDeviceRegistration()
                     .then((devRegistration) => {
                     if (devRegistration) {
-                        session.embedFpResultToDeviceRegistration(devRegistration).then((devRegistration) => {
-                            this.finishRegistration(session, [this.getFido2Registration(session)], devRegistration.getSignals())
-                                .then(resolve)
-                                .catch(reject);
-                        });
+                        this.finishRegistration(session, [this.getFido2Registration(session)])
+                            .then(resolve)
+                            .catch(reject);
                     }
                     else {
                         session.platform.deviceAuth
@@ -35,11 +33,13 @@ class DevicePassiveRegisterStep {
                             namespace: session.namespace,
                             endpoint: session.backendOrigin,
                         })
-                            .then((devRegistration) => session.embedFpResultToDeviceRegistration(devRegistration))
                             .then((devRegistration) => {
                             devRegistration
                                 .getAuthRegistration(session.challenge)
-                                .then((authRegistration) => this.finishRegistration(session, [this.getFido2Registration(session), authRegistration], devRegistration.getSignals()))
+                                .then((authRegistration) => this.finishRegistration(session, [
+                                this.getFido2Registration(session),
+                                authRegistration,
+                            ]))
                                 .then((next) => {
                                 devRegistration.deviceId = session.settings.deviceId;
                                 session.platform.deviceAuth
@@ -61,14 +61,13 @@ class DevicePassiveRegisterStep {
         const assertion = credential.response;
         return assertion && 'authenticatorData' in assertion && 'signature' in assertion;
     }
-    finishRegistration(session, registrations, signals) {
+    finishRegistration(session, registrations) {
         return new Promise((resolve, reject) => {
             session
                 .fetchFromBackend('/v1/client/device/fido2/register/finish', {
                 deviceName: session.platform.getPlatformName(),
                 deviceCapabilities: session.platform.getDeviceCapabilities(),
                 registrations: registrations,
-                signals: signals,
             })
                 .then((response) => {
                 if (response.error) {

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

@@ -70,10 +70,14 @@ class DevicePassiveSilentStep {
                     signals: registration.getSignals(),
                 })
                     .then((response) => {
+                    var _a;
                     if (response.error) {
                         reject(new auth_error_1.default(response.error.message, response.error.code, response.next, false));
                     }
                     else {
+                        if ((_a = registration.getSignals().fingerprint) === null || _a === void 0 ? void 0 : _a.results) {
+                            session.markNewFptts();
+                        }
                         const deviceRegisterAuthResp = response;
                         const deviceId = deviceRegisterAuthResp.data.deviceId;
                         if (!deviceId) {
@@ -113,10 +117,14 @@ class DevicePassiveSilentStep {
                         signals: registration.getSignals(),
                     })
                         .then((response) => {
+                        var _a;
                         if (response.error) {
                             reject(new auth_error_1.default(response.error.message, response.error.code, response.next, false));
                         }
                         else {
+                            if ((_a = registration.getSignals().fingerprint) === null || _a === void 0 ? void 0 : _a.results) {
+                                session.markNewFptts();
+                            }
                             resolve(response.next);
                         }
                     })

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

@@ -30,13 +30,16 @@ class DevicePassiveActions extends auth_status_actions_1.AuthStatusActions {
                 signals: signals,
             })
                 .then((response) => {
-                var _a, _b;
+                var _a, _b, _c;
                 if (response.error) {
                     reject(new auth_error_1.default(response.error.message, response.error.code, response.next, false));
                 }
                 else {
-                    const creationOptions = (_a = response.data) === null || _a === void 0 ? void 0 : _a.credCreateOptions;
-                    const requestOptions = (_b = response.data) === null || _b === void 0 ? void 0 : _b.credRequestOptions;
+                    if ((_a = signals === null || signals === void 0 ? void 0 : signals.fingerprint) === null || _a === void 0 ? void 0 : _a.results) {
+                        session.markNewFptts();
+                    }
+                    const creationOptions = (_b = response.data) === null || _b === void 0 ? void 0 : _b.credCreateOptions;
+                    const requestOptions = (_c = response.data) === null || _c === void 0 ? void 0 : _c.credRequestOptions;
                     if (creationOptions) {
                         this.createCredentials(session, displayName, creationOptions, response)
                             .then(resolve)

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

@@ -19,25 +19,7 @@ class DevicePassiveStepupStep extends device_passive_step_1.DevicePassiveActions
             return Promise.reject(new Error('FIDO2 Passkey is already registered'));
         }
         return new Promise((resolve, reject) => {
-            session
-                .getFingerprintData()
-                .then((signal) => {
-                const signals = {
-                    fingerprint: signal,
-                };
-                this.register(session, signals).then(resolve).catch(reject);
-            })
-                .catch((error) => {
-                const errorMsg = `Unexpected error happened during Fingerprint data collection: ${error.message}`;
-                this.log.warn(errorMsg);
-                this.log.warn(error);
-                const signals = {
-                    fingerprint: {
-                        error: errorMsg,
-                    },
-                };
-                this.register(session, signals).then(resolve).catch(reject);
-            });
+            this.register(session).then(resolve).catch(reject);
         });
     }
 }

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-instantlink-step.d.ts

@@ -1,15 +1,19 @@
 import AuthSession from './auth-session';
 import AuthStep from './auth-step';
-import { InstantLinkStartStep } from '../instantlink';
+import { InstantLinkRetryStep, InstantLinkStartStep } from '../instantlink';
 import { AuthStatusActions } from './auth-status-actions';
 export default class MobileInstantLinkStep extends AuthStatusActions implements AuthStep {
     static readonly NAME = "mobile/instantlink";
     readonly name = "mobile/instantlink";
     protected log: import("../common/logger").Logger;
     private readonly startStep?;
+    private readonly retryStep?;
     private readonly getDeviceIp;
-    constructor(startStep?: InstantLinkStartStep, getDeviceIp?: () => string | null);
+    constructor(startStep?: InstantLinkStartStep, retryStep?: InstantLinkRetryStep, getDeviceIp?: () => string | null);
+    private isTestMode;
     execute(session: AuthSession): Promise<string>;
+    private getInstantLinkError;
     private runStartStep;
-    private runFinishStep;
+    private runRetryStep;
+    private handleTestMode;
 }

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

@@ -4,46 +4,75 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const logger_1 = require("../common/logger");
+const instantlink_1 = require("../instantlink");
 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) {
+    constructor(startStep, retryStep, getDeviceIp) {
         super();
         this.name = MobileInstantLinkStep.NAME;
         this.log = logger_1.LoggerFactory.getLogger('mobile-instantlink-step');
         this.startStep = startStep;
+        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');
         return new Promise((resolve, reject) => {
-            var _a, _b, _c, _d, _e, _f;
+            var _a, _b, _c;
             var phoneNumberNeeded = true;
             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.mnp) {
                 phoneNumberNeeded = false;
             }
-            var testMode = false;
-            if ((_f = (_e = (_d = session.claims) === null || _d === void 0 ? void 0 : _d.auth.subs.mob) === null || _e === void 0 ? void 0 : _e.auths.inln) === null || _f === void 0 ? void 0 : _f.tme) {
-                testMode = true;
-            }
             this.runStartStep(session, phoneNumberNeeded)
-                .then((_) => {
-                this.runFinishStep(session, testMode)
-                    .then(() => this.waitForStatus(session))
-                    .then((next) => resolve(next))
-                    .catch(reject);
-            })
                 .catch(reject);
+            this.waitForStatus(session).then(resolve).catch(reject);
         });
     }
-    runStartStep(session, phoneNumberNeeded, phoneValidationError) {
+    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) {
                 this.startStep
-                    .execute(phoneNumberNeeded, phoneValidationError)
+                    .execute(phoneNumberNeeded, instantLinkError)
                     .then((input) => {
                     const inputError = mobile_otp_step_1.default.validatePhoneNumberInput(input);
                     if (inputError) {
@@ -56,30 +85,55 @@ class MobileInstantLinkStep extends auth_status_actions_1.AuthStatusActions {
                             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) {
+                                const errorCode = authResponse.data.code;
                                 var errorMessage = '';
-                                if ((_a = authResponse.data) === null || _a === void 0 ? void 0 : _a.code) {
+                                if (errorCode) {
                                     errorMessage += `Error Code: ${authResponse.data.code}, `;
                                 }
-                                if ((_b = authResponse.data) === null || _b === void 0 ? void 0 : _b.message) {
-                                    errorMessage += `${authResponse.data.message}`;
+                                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.');
+                                    }
                                 }
                                 else {
-                                    errorMessage += `Error validating phone number`;
+                                    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);
                                 }
-                                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);
+                                this.handleTestMode(session)
+                                    .then(() => {
+                                    if (this.retryStep) {
+                                        this.runRetryStep(session).then(resolve).catch(reject);
+                                    }
+                                    else {
+                                        resolve(authResponse.next);
+                                    }
+                                })
+                                    .catch(reject);
                             }
                         })
                             .catch(reject);
@@ -92,9 +146,65 @@ class MobileInstantLinkStep extends auth_status_actions_1.AuthStatusActions {
             }
         });
     }
-    runFinishStep(session, testMode) {
+    runRetryStep(session, instantLinkError) {
         return new Promise((resolve, reject) => {
-            if (testMode) {
+            if (this.retryStep) {
+                this.retryStep
+                    .execute(instantLinkError)
+                    .then((resultType) => {
+                    if (resultType === instantlink_1.InstantLinkResultType.OnResend) {
+                        session
+                            .fetchFromBackend('/v1/client/mobile/instantlink/start', {
+                            sourceIp: this.getDeviceIp(),
+                            mobileNumber: '',
+                        })
+                            .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) {
+                                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);
+                            }
+                        })
+                            .catch(reject);
+                    }
+                    else if (resultType === instantlink_1.InstantLinkResultType.OnMobileNumberChange) {
+                        this.runStartStep(session, true).then(resolve).catch(reject);
+                    }
+                    else {
+                        this.log.warn('Unkown enum of ', resultType);
+                    }
+                })
+                    .catch(reject);
+            }
+            else {
+                this.log.debug("Retry step doesn't exsist, 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
@@ -105,10 +215,11 @@ class MobileInstantLinkStep extends auth_status_actions_1.AuthStatusActions {
                         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));
-                    })
-                        .finally(resolve);
+                        reject(e);
+                    });
                 }, SIMULATED_LINK_CLICK_DELAY);
             }
             else {

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

@@ -13,5 +13,6 @@ export default class MobileOtpStep implements AuthStep {
     static validatePhoneNumberInput(input: any): AuthError | undefined;
     private runOtpStartStep;
     static validateFinishResult(result: any): AuthError | undefined;
+    private resendOtp;
     private runOtpFinishStep;
 }