@aws-amplify/auth 6.10.2-unstable.e888e7c.0 → 6.10.2

package/src/providers/cognito/utils/handleDeviceSRPAuth.ts

@@ -0,0 +1,146 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { CognitoUserPoolConfig } from '@aws-amplify/core';
+
+import { ClientMetadata } from '../types';
+import { AuthTokenOrchestrator } from '../tokenProvider/types';
+import { createRespondToAuthChallengeClient } from '../../../foundation/factories/serviceClients/cognitoIdentityProvider';
+import { createCognitoUserPoolEndpointResolver } from '../factories';
+import {
+	ChallengeParameters,
+	RespondToAuthChallengeCommandInput,
+	RespondToAuthChallengeCommandOutput,
+} from '../../../foundation/factories/serviceClients/cognitoIdentityProvider/types';
+import { getRegionFromUserPoolId } from '../../../foundation/parsers';
+
+import { assertDeviceMetadata } from './types';
+import {
+	getAuthenticationHelper,
+	getNowString,
+	getSignatureString,
+} from './srp';
+import { BigInteger } from './srp/BigInteger';
+import { AuthenticationHelper } from './srp/AuthenticationHelper';
+import { getUserContextData } from './userContextData';
+
+interface HandleDeviceSRPInput {
+	username: string;
+	config: CognitoUserPoolConfig;
+	clientMetadata: ClientMetadata | undefined;
+	session: string | undefined;
+	tokenOrchestrator?: AuthTokenOrchestrator;
+}
+
+export async function handleDeviceSRPAuth({
+	username,
+	config,
+	clientMetadata,
+	session,
+	tokenOrchestrator,
+}: HandleDeviceSRPInput): Promise<RespondToAuthChallengeCommandOutput> {
+	const { userPoolId, userPoolEndpoint } = config;
+	const clientId = config.userPoolClientId;
+	const deviceMetadata = await tokenOrchestrator?.getDeviceMetadata(username);
+	assertDeviceMetadata(deviceMetadata);
+	const authenticationHelper = await getAuthenticationHelper(
+		deviceMetadata.deviceGroupKey,
+	);
+	const challengeResponses: Record<string, string> = {
+		USERNAME: username,
+		SRP_A: authenticationHelper.A.toString(16),
+		DEVICE_KEY: deviceMetadata.deviceKey,
+	};
+
+	const jsonReqResponseChallenge: RespondToAuthChallengeCommandInput = {
+		ChallengeName: 'DEVICE_SRP_AUTH',
+		ClientId: clientId,
+		ChallengeResponses: challengeResponses,
+		ClientMetadata: clientMetadata,
+		Session: session,
+	};
+	const respondToAuthChallenge = createRespondToAuthChallengeClient({
+		endpointResolver: createCognitoUserPoolEndpointResolver({
+			endpointOverride: userPoolEndpoint,
+		}),
+	});
+	const { ChallengeParameters: respondedChallengeParameters, Session } =
+		await respondToAuthChallenge(
+			{ region: getRegionFromUserPoolId(userPoolId) },
+			jsonReqResponseChallenge,
+		);
+
+	return handleDevicePasswordVerifier(
+		username,
+		respondedChallengeParameters as ChallengeParameters,
+		clientMetadata,
+		Session,
+		authenticationHelper,
+		config,
+		tokenOrchestrator,
+	);
+}
+
+async function handleDevicePasswordVerifier(
+	username: string,
+	challengeParameters: ChallengeParameters,
+	clientMetadata: ClientMetadata | undefined,
+	session: string | undefined,
+	authenticationHelper: AuthenticationHelper,
+	{ userPoolId, userPoolClientId, userPoolEndpoint }: CognitoUserPoolConfig,
+	tokenOrchestrator?: AuthTokenOrchestrator,
+): Promise<RespondToAuthChallengeCommandOutput> {
+	const deviceMetadata = await tokenOrchestrator?.getDeviceMetadata(username);
+	assertDeviceMetadata(deviceMetadata);
+
+	const serverBValue = new BigInteger(challengeParameters?.SRP_B, 16);
+	const salt = new BigInteger(challengeParameters?.SALT, 16);
+	const { deviceKey } = deviceMetadata;
+	const { deviceGroupKey } = deviceMetadata;
+	const hkdf = await authenticationHelper.getPasswordAuthenticationKey({
+		username: deviceMetadata.deviceKey,
+		password: deviceMetadata.randomPassword,
+		serverBValue,
+		salt,
+	});
+
+	const dateNow = getNowString();
+	const challengeResponses = {
+		USERNAME: (challengeParameters?.USERNAME as string) ?? username,
+		PASSWORD_CLAIM_SECRET_BLOCK: challengeParameters?.SECRET_BLOCK,
+		TIMESTAMP: dateNow,
+		PASSWORD_CLAIM_SIGNATURE: getSignatureString({
+			username: deviceKey,
+			userPoolName: deviceGroupKey,
+			challengeParameters,
+			dateNow,
+			hkdf,
+		}),
+		DEVICE_KEY: deviceKey,
+	} as Record<string, string>;
+
+	const UserContextData = getUserContextData({
+		username,
+		userPoolId,
+		userPoolClientId,
+	});
+
+	const jsonReqResponseChallenge: RespondToAuthChallengeCommandInput = {
+		ChallengeName: 'DEVICE_PASSWORD_VERIFIER',
+		ClientId: userPoolClientId,
+		ChallengeResponses: challengeResponses,
+		Session: session,
+		ClientMetadata: clientMetadata,
+		UserContextData,
+	};
+	const respondToAuthChallenge = createRespondToAuthChallengeClient({
+		endpointResolver: createCognitoUserPoolEndpointResolver({
+			endpointOverride: userPoolEndpoint,
+		}),
+	});
+
+	return respondToAuthChallenge(
+		{ region: getRegionFromUserPoolId(userPoolId) },
+		jsonReqResponseChallenge,
+	);
+}

package/src/providers/cognito/utils/handlePasswordVerifierChallenge.ts

@@ -0,0 +1,106 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { CognitoUserPoolConfig } from '@aws-amplify/core';
+
+import { ClientMetadata } from '../types';
+import { AuthError } from '../../../errors/AuthError';
+import { AuthTokenOrchestrator } from '../tokenProvider/types';
+import { createRespondToAuthChallengeClient } from '../../../foundation/factories/serviceClients/cognitoIdentityProvider';
+import { createCognitoUserPoolEndpointResolver } from '../factories';
+import {
+	ChallengeParameters,
+	RespondToAuthChallengeCommandInput,
+	RespondToAuthChallengeCommandOutput,
+} from '../../../foundation/factories/serviceClients/cognitoIdentityProvider/types';
+import { getRegionFromUserPoolId } from '../../../foundation/parsers';
+
+import { getNowString, getSignatureString } from './srp';
+import { BigInteger } from './srp/BigInteger';
+import { AuthenticationHelper } from './srp/AuthenticationHelper';
+import { getUserContextData } from './userContextData';
+import { handleDeviceSRPAuth } from './handleDeviceSRPAuth';
+
+export async function handlePasswordVerifierChallenge(
+	password: string,
+	challengeParameters: ChallengeParameters,
+	clientMetadata: ClientMetadata | undefined,
+	session: string | undefined,
+	authenticationHelper: AuthenticationHelper,
+	config: CognitoUserPoolConfig,
+	tokenOrchestrator: AuthTokenOrchestrator,
+): Promise<RespondToAuthChallengeCommandOutput> {
+	const { userPoolId, userPoolClientId, userPoolEndpoint } = config;
+	const userPoolName = userPoolId?.split('_')[1] || '';
+	const serverBValue = new (BigInteger as any)(challengeParameters?.SRP_B, 16);
+	const salt = new (BigInteger as any)(challengeParameters?.SALT, 16);
+	const username = challengeParameters?.USER_ID_FOR_SRP;
+	if (!username)
+		throw new AuthError({
+			name: 'EmptyUserIdForSRPException',
+			message: 'USER_ID_FOR_SRP was not found in challengeParameters',
+		});
+	const hkdf = await authenticationHelper.getPasswordAuthenticationKey({
+		username,
+		password,
+		serverBValue,
+		salt,
+	});
+
+	const dateNow = getNowString();
+
+	const challengeResponses = {
+		USERNAME: username,
+		PASSWORD_CLAIM_SECRET_BLOCK: challengeParameters?.SECRET_BLOCK,
+		TIMESTAMP: dateNow,
+		PASSWORD_CLAIM_SIGNATURE: getSignatureString({
+			username,
+			userPoolName,
+			challengeParameters,
+			dateNow,
+			hkdf,
+		}),
+	} as Record<string, string>;
+
+	const deviceMetadata = await tokenOrchestrator.getDeviceMetadata(username);
+	if (deviceMetadata && deviceMetadata.deviceKey) {
+		challengeResponses.DEVICE_KEY = deviceMetadata.deviceKey;
+	}
+
+	const UserContextData = getUserContextData({
+		username,
+		userPoolId,
+		userPoolClientId,
+	});
+
+	const jsonReqResponseChallenge: RespondToAuthChallengeCommandInput = {
+		ChallengeName: 'PASSWORD_VERIFIER',
+		ChallengeResponses: challengeResponses,
+		ClientMetadata: clientMetadata,
+		Session: session,
+		ClientId: userPoolClientId,
+		UserContextData,
+	};
+
+	const respondToAuthChallenge = createRespondToAuthChallengeClient({
+		endpointResolver: createCognitoUserPoolEndpointResolver({
+			endpointOverride: userPoolEndpoint,
+		}),
+	});
+
+	const response = await respondToAuthChallenge(
+		{ region: getRegionFromUserPoolId(userPoolId) },
+		jsonReqResponseChallenge,
+	);
+
+	if (response.ChallengeName === 'DEVICE_SRP_AUTH')
+		return handleDeviceSRPAuth({
+			username,
+			config,
+			clientMetadata,
+			session: response.Session,
+			tokenOrchestrator,
+		});
+
+	return response;
+}

package/src/providers/cognito/utils/retryOnResourceNotFoundException.ts

@@ -0,0 +1,34 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { AuthError } from '../../../errors/AuthError';
+import { AuthTokenOrchestrator } from '../tokenProvider/types';
+
+/**
+ * It will retry the function if the error is a `ResourceNotFoundException` and
+ * will clean the device keys stored in the storage mechanism.
+ *
+ */
+export async function retryOnResourceNotFoundException<
+	F extends (...args: any[]) => any,
+>(
+	func: F,
+	args: Parameters<F>,
+	username: string,
+	tokenOrchestrator: AuthTokenOrchestrator,
+): Promise<ReturnType<F>> {
+	try {
+		return await func(...args);
+	} catch (error) {
+		if (
+			error instanceof AuthError &&
+			error.name === 'ResourceNotFoundException' &&
+			error.message.includes('Device does not exist.')
+		) {
+			await tokenOrchestrator.clearDeviceMetadata(username);
+
+			return func(...args);
+		}
+		throw error;
+	}
+}

package/src/providers/cognito/utils/setActiveSignInUsername.ts

@@ -0,0 +1,10 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { signInStore } from '../../../client/utils/store';
+
+export function setActiveSignInUsername(username: string) {
+	const { dispatch } = signInStore;
+
+	dispatch({ type: 'SET_USERNAME', value: username });
+}

package/src/providers/cognito/utils/signInHelpers.ts

@@ -6,8 +6,6 @@ import {
 	AmplifyUrl,
 	AuthAction,
 	assertTokenProviderConfig,
-	base64Encoder,
-	getDeviceName,
 } from '@aws-amplify/core/internals/utils';
 
 import { ClientMetadata, ConfirmSignInOptions } from '../types';
@@ -29,11 +27,10 @@ import { AuthValidationErrorCode } from '../../../errors/types/validation';
 import { assertValidationError } from '../../../errors/utils/assertValidationError';
 import { USER_ALREADY_AUTHENTICATED_EXCEPTION } from '../../../errors/constants';
 import { getCurrentUser } from '../apis/getCurrentUser';
-import { AuthTokenOrchestrator, DeviceMetadata } from '../tokenProvider/types';
+import { AuthTokenOrchestrator } from '../tokenProvider/types';
 import { getAuthUserAgentValue } from '../../../utils';
 import {
 	createAssociateSoftwareTokenClient,
-	createConfirmDeviceClient,
 	createInitiateAuthClient,
 	createRespondToAuthChallengeClient,
 	createVerifySoftwareTokenClient,
@@ -45,7 +42,6 @@ import {
 	CognitoMFAType,
 	InitiateAuthCommandInput,
 	InitiateAuthCommandOutput,
-	NewDeviceMetadataType,
 	RespondToAuthChallengeCommandInput,
 	RespondToAuthChallengeCommandOutput,
 } from '../../../foundation/factories/serviceClients/cognitoIdentityProvider/types';
@@ -56,17 +52,14 @@ import { initiateSelectedChallenge } from '../../../client/flows/userAuth/handle
 import { handleSelectChallengeWithPassword } from '../../../client/flows/userAuth/handleSelectChallengeWithPassword';
 import { handleSelectChallengeWithPasswordSRP } from '../../../client/flows/userAuth/handleSelectChallengeWithPasswordSRP';
 import { signInStore } from '../../../client/utils/store';
+import { WebAuthnSignInResult } from '../../../client/flows/userAuth/types';
 
-import { assertDeviceMetadata } from './types';
-import {
-	getAuthenticationHelper,
-	getBytesFromHex,
-	getNowString,
-	getSignatureString,
-} from './srp';
-import { BigInteger } from './srp/BigInteger';
-import { AuthenticationHelper } from './srp/AuthenticationHelper';
+import { getAuthenticationHelper } from './srp';
 import { getUserContextData } from './userContextData';
+import { handlePasswordVerifierChallenge } from './handlePasswordVerifierChallenge';
+import { handleDeviceSRPAuth } from './handleDeviceSRPAuth';
+import { retryOnResourceNotFoundException } from './retryOnResourceNotFoundException';
+import { setActiveSignInUsername } from './setActiveSignInUsername';
 
 const USER_ATTRIBUTES = 'userAttributes.';
 
@@ -80,12 +73,10 @@ interface HandleAuthChallengeRequest {
 	config: CognitoUserPoolConfig;
 }
 
-interface HandleDeviceSRPInput {
-	username: string;
-	config: CognitoUserPoolConfig;
-	clientMetadata: ClientMetadata | undefined;
-	session: string | undefined;
-	tokenOrchestrator?: AuthTokenOrchestrator;
+function isWebAuthnResultAuthSignInOutput(
+	result: WebAuthnSignInResult,
+): result is AuthSignInOutput {
+	return 'isSignedIn' in result && 'nextStep' in result;
 }
 
 export async function handleCustomChallenge({
@@ -571,203 +562,6 @@ export async function handleCustomSRPAuthFlow(
 	);
 }
 
-async function handleDeviceSRPAuth({
-	username,
-	config,
-	clientMetadata,
-	session,
-	tokenOrchestrator,
-}: HandleDeviceSRPInput): Promise<RespondToAuthChallengeCommandOutput> {
-	const { userPoolId, userPoolEndpoint } = config;
-	const clientId = config.userPoolClientId;
-	const deviceMetadata = await tokenOrchestrator?.getDeviceMetadata(username);
-	assertDeviceMetadata(deviceMetadata);
-	const authenticationHelper = await getAuthenticationHelper(
-		deviceMetadata.deviceGroupKey,
-	);
-	const challengeResponses: Record<string, string> = {
-		USERNAME: username,
-		SRP_A: authenticationHelper.A.toString(16),
-		DEVICE_KEY: deviceMetadata.deviceKey,
-	};
-
-	const jsonReqResponseChallenge: RespondToAuthChallengeCommandInput = {
-		ChallengeName: 'DEVICE_SRP_AUTH',
-		ClientId: clientId,
-		ChallengeResponses: challengeResponses,
-		ClientMetadata: clientMetadata,
-		Session: session,
-	};
-	const respondToAuthChallenge = createRespondToAuthChallengeClient({
-		endpointResolver: createCognitoUserPoolEndpointResolver({
-			endpointOverride: userPoolEndpoint,
-		}),
-	});
-	const { ChallengeParameters: respondedChallengeParameters, Session } =
-		await respondToAuthChallenge(
-			{ region: getRegionFromUserPoolId(userPoolId) },
-			jsonReqResponseChallenge,
-		);
-
-	return handleDevicePasswordVerifier(
-		username,
-		respondedChallengeParameters as ChallengeParameters,
-		clientMetadata,
-		Session,
-		authenticationHelper,
-		config,
-		tokenOrchestrator,
-	);
-}
-
-async function handleDevicePasswordVerifier(
-	username: string,
-	challengeParameters: ChallengeParameters,
-	clientMetadata: ClientMetadata | undefined,
-	session: string | undefined,
-	authenticationHelper: AuthenticationHelper,
-	{ userPoolId, userPoolClientId, userPoolEndpoint }: CognitoUserPoolConfig,
-	tokenOrchestrator?: AuthTokenOrchestrator,
-): Promise<RespondToAuthChallengeCommandOutput> {
-	const deviceMetadata = await tokenOrchestrator?.getDeviceMetadata(username);
-	assertDeviceMetadata(deviceMetadata);
-
-	const serverBValue = new BigInteger(challengeParameters?.SRP_B, 16);
-	const salt = new BigInteger(challengeParameters?.SALT, 16);
-	const { deviceKey } = deviceMetadata;
-	const { deviceGroupKey } = deviceMetadata;
-	const hkdf = await authenticationHelper.getPasswordAuthenticationKey({
-		username: deviceMetadata.deviceKey,
-		password: deviceMetadata.randomPassword,
-		serverBValue,
-		salt,
-	});
-
-	const dateNow = getNowString();
-	const challengeResponses = {
-		USERNAME: (challengeParameters?.USERNAME as string) ?? username,
-		PASSWORD_CLAIM_SECRET_BLOCK: challengeParameters?.SECRET_BLOCK,
-		TIMESTAMP: dateNow,
-		PASSWORD_CLAIM_SIGNATURE: getSignatureString({
-			username: deviceKey,
-			userPoolName: deviceGroupKey,
-			challengeParameters,
-			dateNow,
-			hkdf,
-		}),
-		DEVICE_KEY: deviceKey,
-	} as Record<string, string>;
-
-	const UserContextData = getUserContextData({
-		username,
-		userPoolId,
-		userPoolClientId,
-	});
-
-	const jsonReqResponseChallenge: RespondToAuthChallengeCommandInput = {
-		ChallengeName: 'DEVICE_PASSWORD_VERIFIER',
-		ClientId: userPoolClientId,
-		ChallengeResponses: challengeResponses,
-		Session: session,
-		ClientMetadata: clientMetadata,
-		UserContextData,
-	};
-	const respondToAuthChallenge = createRespondToAuthChallengeClient({
-		endpointResolver: createCognitoUserPoolEndpointResolver({
-			endpointOverride: userPoolEndpoint,
-		}),
-	});
-
-	return respondToAuthChallenge(
-		{ region: getRegionFromUserPoolId(userPoolId) },
-		jsonReqResponseChallenge,
-	);
-}
-
-export async function handlePasswordVerifierChallenge(
-	password: string,
-	challengeParameters: ChallengeParameters,
-	clientMetadata: ClientMetadata | undefined,
-	session: string | undefined,
-	authenticationHelper: AuthenticationHelper,
-	config: CognitoUserPoolConfig,
-	tokenOrchestrator: AuthTokenOrchestrator,
-): Promise<RespondToAuthChallengeCommandOutput> {
-	const { userPoolId, userPoolClientId, userPoolEndpoint } = config;
-	const userPoolName = userPoolId?.split('_')[1] || '';
-	const serverBValue = new (BigInteger as any)(challengeParameters?.SRP_B, 16);
-	const salt = new (BigInteger as any)(challengeParameters?.SALT, 16);
-	const username = challengeParameters?.USER_ID_FOR_SRP;
-	if (!username)
-		throw new AuthError({
-			name: 'EmptyUserIdForSRPException',
-			message: 'USER_ID_FOR_SRP was not found in challengeParameters',
-		});
-	const hkdf = await authenticationHelper.getPasswordAuthenticationKey({
-		username,
-		password,
-		serverBValue,
-		salt,
-	});
-
-	const dateNow = getNowString();
-
-	const challengeResponses = {
-		USERNAME: username,
-		PASSWORD_CLAIM_SECRET_BLOCK: challengeParameters?.SECRET_BLOCK,
-		TIMESTAMP: dateNow,
-		PASSWORD_CLAIM_SIGNATURE: getSignatureString({
-			username,
-			userPoolName,
-			challengeParameters,
-			dateNow,
-			hkdf,
-		}),
-	} as Record<string, string>;
-
-	const deviceMetadata = await tokenOrchestrator.getDeviceMetadata(username);
-	if (deviceMetadata && deviceMetadata.deviceKey) {
-		challengeResponses.DEVICE_KEY = deviceMetadata.deviceKey;
-	}
-
-	const UserContextData = getUserContextData({
-		username,
-		userPoolId,
-		userPoolClientId,
-	});
-
-	const jsonReqResponseChallenge: RespondToAuthChallengeCommandInput = {
-		ChallengeName: 'PASSWORD_VERIFIER',
-		ChallengeResponses: challengeResponses,
-		ClientMetadata: clientMetadata,
-		Session: session,
-		ClientId: userPoolClientId,
-		UserContextData,
-	};
-
-	const respondToAuthChallenge = createRespondToAuthChallengeClient({
-		endpointResolver: createCognitoUserPoolEndpointResolver({
-			endpointOverride: userPoolEndpoint,
-		}),
-	});
-
-	const response = await respondToAuthChallenge(
-		{ region: getRegionFromUserPoolId(userPoolId) },
-		jsonReqResponseChallenge,
-	);
-
-	if (response.ChallengeName === 'DEVICE_SRP_AUTH')
-		return handleDeviceSRPAuth({
-			username,
-			config,
-			clientMetadata,
-			session: response.Session,
-			tokenOrchestrator,
-		});
-
-	return response;
-}
-
 export async function getSignInResult(params: {
 	challengeName: ChallengeName;
 	challengeParameters: ChallengeParameters;
@@ -902,8 +696,14 @@ export async function getSignInResult(params: {
 				},
 			};
 
-		case 'WEB_AUTHN':
-			return handleWebAuthnSignInResult(challengeParameters);
+		case 'WEB_AUTHN': {
+			const result = await handleWebAuthnSignInResult(challengeParameters);
+			if (isWebAuthnResultAuthSignInOutput(result)) {
+				return result;
+			}
+
+			return getSignInResult(result);
+		}
 		case 'PASSWORD':
 		case 'PASSWORD_SRP':
 			return {
@@ -1154,114 +954,6 @@ export async function assertUserNotAuthenticated() {
 	}
 }
 
-/**
- * This function is used to kick off the device management flow.
- *
- * If an error is thrown while generating a hash device or calling the `ConfirmDevice`
- * client, then this API will ignore the error and return undefined. Otherwise the authentication
- * flow will not complete and the user won't be able to be signed in.
- *
- * @returns DeviceMetadata | undefined
- */
-export async function getNewDeviceMetadata({
-	userPoolId,
-	userPoolEndpoint,
-	newDeviceMetadata,
-	accessToken,
-}: {
-	userPoolId: string;
-	userPoolEndpoint: string | undefined;
-	newDeviceMetadata?: NewDeviceMetadataType;
-	accessToken?: string;
-}): Promise<DeviceMetadata | undefined> {
-	if (!newDeviceMetadata) return undefined;
-	const userPoolName = userPoolId.split('_')[1] || '';
-	const authenticationHelper = await getAuthenticationHelper(userPoolName);
-	const deviceKey = newDeviceMetadata?.DeviceKey;
-	const deviceGroupKey = newDeviceMetadata?.DeviceGroupKey;
-
-	try {
-		await authenticationHelper.generateHashDevice(
-			deviceGroupKey ?? '',
-			deviceKey ?? '',
-		);
-	} catch (errGenHash) {
-		// TODO: log error here
-		return undefined;
-	}
-
-	const deviceSecretVerifierConfig = {
-		Salt: base64Encoder.convert(
-			getBytesFromHex(authenticationHelper.getSaltToHashDevices()),
-		),
-		PasswordVerifier: base64Encoder.convert(
-			getBytesFromHex(authenticationHelper.getVerifierDevices()),
-		),
-	};
-	const randomPassword = authenticationHelper.getRandomPassword();
-
-	try {
-		const confirmDevice = createConfirmDeviceClient({
-			endpointResolver: createCognitoUserPoolEndpointResolver({
-				endpointOverride: userPoolEndpoint,
-			}),
-		});
-		await confirmDevice(
-			{ region: getRegionFromUserPoolId(userPoolId) },
-			{
-				AccessToken: accessToken,
-				DeviceName: await getDeviceName(),
-				DeviceKey: newDeviceMetadata?.DeviceKey,
-				DeviceSecretVerifierConfig: deviceSecretVerifierConfig,
-			},
-		);
-
-		return {
-			deviceKey,
-			deviceGroupKey,
-			randomPassword,
-		};
-	} catch (error) {
-		// TODO: log error here
-		return undefined;
-	}
-}
-
-/**
- * It will retry the function if the error is a `ResourceNotFoundException` and
- * will clean the device keys stored in the storage mechanism.
- *
- */
-export async function retryOnResourceNotFoundException<
-	F extends (...args: any[]) => any,
->(
-	func: F,
-	args: Parameters<F>,
-	username: string,
-	tokenOrchestrator: AuthTokenOrchestrator,
-): Promise<ReturnType<F>> {
-	try {
-		return await func(...args);
-	} catch (error) {
-		if (
-			error instanceof AuthError &&
-			error.name === 'ResourceNotFoundException' &&
-			error.message.includes('Device does not exist.')
-		) {
-			await tokenOrchestrator.clearDeviceMetadata(username);
-
-			return func(...args);
-		}
-		throw error;
-	}
-}
-
-export function setActiveSignInUsername(username: string) {
-	const { dispatch } = signInStore;
-
-	dispatch({ type: 'SET_USERNAME', value: username });
-}
-
 export function getActiveSignInUsername(username: string): string {
 	const state = signInStore.getState();