@azure/msal-common 14.0.1 → 14.0.3

package/src/utils/Constants.ts

@@ -0,0 +1,436 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export const Constants = {
+    LIBRARY_NAME: "MSAL.JS",
+    SKU: "msal.js.common",
+    // Prefix for all library cache entries
+    CACHE_PREFIX: "msal",
+    // default authority
+    DEFAULT_AUTHORITY: "https://login.microsoftonline.com/common/",
+    DEFAULT_AUTHORITY_HOST: "login.microsoftonline.com",
+    DEFAULT_COMMON_TENANT: "common",
+    // ADFS String
+    ADFS: "adfs",
+    DSTS: "dstsv2",
+    // Default AAD Instance Discovery Endpoint
+    AAD_INSTANCE_DISCOVERY_ENDPT:
+        "https://login.microsoftonline.com/common/discovery/instance?api-version=1.1&authorization_endpoint=",
+    // CIAM URL
+    CIAM_AUTH_URL: ".ciamlogin.com",
+    AAD_TENANT_DOMAIN_SUFFIX: ".onmicrosoft.com",
+    // Resource delimiter - used for certain cache entries
+    RESOURCE_DELIM: "|",
+    // Placeholder for non-existent account ids/objects
+    NO_ACCOUNT: "NO_ACCOUNT",
+    // Claims
+    CLAIMS: "claims",
+    // Consumer UTID
+    CONSUMER_UTID: "9188040d-6c67-4c5b-b112-36a304b66dad",
+    // Default scopes
+    OPENID_SCOPE: "openid",
+    PROFILE_SCOPE: "profile",
+    OFFLINE_ACCESS_SCOPE: "offline_access",
+    EMAIL_SCOPE: "email",
+    // Default response type for authorization code flow
+    CODE_RESPONSE_TYPE: "code",
+    CODE_GRANT_TYPE: "authorization_code",
+    RT_GRANT_TYPE: "refresh_token",
+    FRAGMENT_RESPONSE_MODE: "fragment",
+    S256_CODE_CHALLENGE_METHOD: "S256",
+    URL_FORM_CONTENT_TYPE: "application/x-www-form-urlencoded;charset=utf-8",
+    AUTHORIZATION_PENDING: "authorization_pending",
+    NOT_DEFINED: "not_defined",
+    EMPTY_STRING: "",
+    NOT_APPLICABLE: "N/A",
+    FORWARD_SLASH: "/",
+    IMDS_ENDPOINT: "http://169.254.169.254/metadata/instance/compute/location",
+    IMDS_VERSION: "2020-06-01",
+    IMDS_TIMEOUT: 2000,
+    AZURE_REGION_AUTO_DISCOVER_FLAG: "TryAutoDetect",
+    REGIONAL_AUTH_PUBLIC_CLOUD_SUFFIX: "login.microsoft.com",
+    REGIONAL_AUTH_NON_MSI_QUERY_STRING: "allowestsrnonmsi=true",
+    KNOWN_PUBLIC_CLOUDS: [
+        "login.microsoftonline.com",
+        "login.windows.net",
+        "login.microsoft.com",
+        "sts.windows.net",
+    ],
+    TOKEN_RESPONSE_TYPE: "token",
+    ID_TOKEN_RESPONSE_TYPE: "id_token",
+    SHR_NONCE_VALIDITY: 240,
+    INVALID_INSTANCE: "invalid_instance",
+};
+
+export const HttpStatus = {
+    SUCCESS_RANGE_START: 200,
+    SUCCESS_RANGE_END: 299,
+    REDIRECT: 302,
+    CLIENT_ERROR_RANGE_START: 400,
+    CLIENT_ERROR_RANGE_END: 499,
+    SERVER_ERROR_RANGE_START: 500,
+    SERVER_ERROR_RANGE_END: 599,
+} as const;
+export type HttpStatus = (typeof HttpStatus)[keyof typeof HttpStatus];
+
+export const OIDC_DEFAULT_SCOPES = [
+    Constants.OPENID_SCOPE,
+    Constants.PROFILE_SCOPE,
+    Constants.OFFLINE_ACCESS_SCOPE,
+];
+
+export const OIDC_SCOPES = [...OIDC_DEFAULT_SCOPES, Constants.EMAIL_SCOPE];
+
+/**
+ * Request header names
+ */
+export const HeaderNames = {
+    CONTENT_TYPE: "Content-Type",
+    RETRY_AFTER: "Retry-After",
+    CCS_HEADER: "X-AnchorMailbox",
+    WWWAuthenticate: "WWW-Authenticate",
+    AuthenticationInfo: "Authentication-Info",
+    X_MS_REQUEST_ID: "x-ms-request-id",
+    X_MS_HTTP_VERSION: "x-ms-httpver",
+} as const;
+export type HeaderNames = (typeof HeaderNames)[keyof typeof HeaderNames];
+
+/**
+ * Persistent cache keys MSAL which stay while user is logged in.
+ */
+export const PersistentCacheKeys = {
+    ID_TOKEN: "idtoken",
+    CLIENT_INFO: "client.info",
+    ADAL_ID_TOKEN: "adal.idtoken",
+    ERROR: "error",
+    ERROR_DESC: "error.description",
+    ACTIVE_ACCOUNT: "active-account", // Legacy active-account cache key, use new key instead
+    ACTIVE_ACCOUNT_FILTERS: "active-account-filters", // new cache entry for active_account for a more robust version for browser
+} as const;
+export type PersistentCacheKeys =
+    (typeof PersistentCacheKeys)[keyof typeof PersistentCacheKeys];
+
+/**
+ * String constants related to AAD Authority
+ */
+export const AADAuthorityConstants = {
+    COMMON: "common",
+    ORGANIZATIONS: "organizations",
+    CONSUMERS: "consumers",
+} as const;
+export type AADAuthorityConstants =
+    (typeof AADAuthorityConstants)[keyof typeof AADAuthorityConstants];
+
+/**
+ * Keys in the hashParams sent by AAD Server
+ */
+export const AADServerParamKeys = {
+    CLIENT_ID: "client_id",
+    REDIRECT_URI: "redirect_uri",
+    RESPONSE_TYPE: "response_type",
+    RESPONSE_MODE: "response_mode",
+    GRANT_TYPE: "grant_type",
+    CLAIMS: "claims",
+    SCOPE: "scope",
+    ERROR: "error",
+    ERROR_DESCRIPTION: "error_description",
+    ACCESS_TOKEN: "access_token",
+    ID_TOKEN: "id_token",
+    REFRESH_TOKEN: "refresh_token",
+    EXPIRES_IN: "expires_in",
+    STATE: "state",
+    NONCE: "nonce",
+    PROMPT: "prompt",
+    SESSION_STATE: "session_state",
+    CLIENT_INFO: "client_info",
+    CODE: "code",
+    CODE_CHALLENGE: "code_challenge",
+    CODE_CHALLENGE_METHOD: "code_challenge_method",
+    CODE_VERIFIER: "code_verifier",
+    CLIENT_REQUEST_ID: "client-request-id",
+    X_CLIENT_SKU: "x-client-SKU",
+    X_CLIENT_VER: "x-client-VER",
+    X_CLIENT_OS: "x-client-OS",
+    X_CLIENT_CPU: "x-client-CPU",
+    X_CLIENT_CURR_TELEM: "x-client-current-telemetry",
+    X_CLIENT_LAST_TELEM: "x-client-last-telemetry",
+    X_MS_LIB_CAPABILITY: "x-ms-lib-capability",
+    X_APP_NAME: "x-app-name",
+    X_APP_VER: "x-app-ver",
+    POST_LOGOUT_URI: "post_logout_redirect_uri",
+    ID_TOKEN_HINT: "id_token_hint",
+    DEVICE_CODE: "device_code",
+    CLIENT_SECRET: "client_secret",
+    CLIENT_ASSERTION: "client_assertion",
+    CLIENT_ASSERTION_TYPE: "client_assertion_type",
+    TOKEN_TYPE: "token_type",
+    REQ_CNF: "req_cnf",
+    OBO_ASSERTION: "assertion",
+    REQUESTED_TOKEN_USE: "requested_token_use",
+    ON_BEHALF_OF: "on_behalf_of",
+    FOCI: "foci",
+    CCS_HEADER: "X-AnchorMailbox",
+    RETURN_SPA_CODE: "return_spa_code",
+    NATIVE_BROKER: "nativebroker",
+    LOGOUT_HINT: "logout_hint",
+} as const;
+export type AADServerParamKeys =
+    (typeof AADServerParamKeys)[keyof typeof AADServerParamKeys];
+
+/**
+ * Claims request keys
+ */
+export const ClaimsRequestKeys = {
+    ACCESS_TOKEN: "access_token",
+    XMS_CC: "xms_cc",
+} as const;
+export type ClaimsRequestKeys =
+    (typeof ClaimsRequestKeys)[keyof typeof ClaimsRequestKeys];
+
+/**
+ * we considered making this "enum" in the request instead of string, however it looks like the allowed list of
+ * prompt values kept changing over past couple of years. There are some undocumented prompt values for some
+ * internal partners too, hence the choice of generic "string" type instead of the "enum"
+ */
+export const PromptValue = {
+    LOGIN: "login",
+    SELECT_ACCOUNT: "select_account",
+    CONSENT: "consent",
+    NONE: "none",
+    CREATE: "create",
+    NO_SESSION: "no_session",
+};
+
+/**
+ * SSO Types - generated to populate hints
+ */
+export const SSOTypes = {
+    ACCOUNT: "account",
+    SID: "sid",
+    LOGIN_HINT: "login_hint",
+    ID_TOKEN: "id_token",
+    DOMAIN_HINT: "domain_hint",
+    ORGANIZATIONS: "organizations",
+    CONSUMERS: "consumers",
+    ACCOUNT_ID: "accountIdentifier",
+    HOMEACCOUNT_ID: "homeAccountIdentifier",
+} as const;
+export type SSOTypes = (typeof SSOTypes)[keyof typeof SSOTypes];
+
+/**
+ * allowed values for codeVerifier
+ */
+export const CodeChallengeMethodValues = {
+    PLAIN: "plain",
+    S256: "S256",
+};
+
+/**
+ * allowed values for server response type
+ */
+export const ServerResponseType = {
+    QUERY: "query",
+    FRAGMENT: "fragment",
+} as const;
+export type ServerResponseType =
+    (typeof ServerResponseType)[keyof typeof ServerResponseType];
+
+/**
+ * allowed values for response_mode
+ */
+export const ResponseMode = {
+    ...ServerResponseType,
+    FORM_POST: "form_post",
+} as const;
+export type ResponseMode = (typeof ResponseMode)[keyof typeof ResponseMode];
+
+/**
+ * allowed grant_type
+ */
+export const GrantType = {
+    IMPLICIT_GRANT: "implicit",
+    AUTHORIZATION_CODE_GRANT: "authorization_code",
+    CLIENT_CREDENTIALS_GRANT: "client_credentials",
+    RESOURCE_OWNER_PASSWORD_GRANT: "password",
+    REFRESH_TOKEN_GRANT: "refresh_token",
+    DEVICE_CODE_GRANT: "device_code",
+    JWT_BEARER: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+} as const;
+export type GrantType = (typeof GrantType)[keyof typeof GrantType];
+
+/**
+ * Account types in Cache
+ */
+export const CacheAccountType = {
+    MSSTS_ACCOUNT_TYPE: "MSSTS",
+    ADFS_ACCOUNT_TYPE: "ADFS",
+    MSAV1_ACCOUNT_TYPE: "MSA",
+    GENERIC_ACCOUNT_TYPE: "Generic", // NTLM, Kerberos, FBA, Basic etc
+} as const;
+export type CacheAccountType =
+    (typeof CacheAccountType)[keyof typeof CacheAccountType];
+
+/**
+ * Separators used in cache
+ */
+export const Separators = {
+    CACHE_KEY_SEPARATOR: "-",
+    CLIENT_INFO_SEPARATOR: ".",
+} as const;
+export type Separators = (typeof Separators)[keyof typeof Separators];
+
+/**
+ * Credential Type stored in the cache
+ */
+export const CredentialType = {
+    ID_TOKEN: "IdToken",
+    ACCESS_TOKEN: "AccessToken",
+    ACCESS_TOKEN_WITH_AUTH_SCHEME: "AccessToken_With_AuthScheme",
+    REFRESH_TOKEN: "RefreshToken",
+} as const;
+export type CredentialType =
+    (typeof CredentialType)[keyof typeof CredentialType];
+
+/**
+ * Combine all cache types
+ */
+export const CacheType = {
+    ADFS: 1001,
+    MSA: 1002,
+    MSSTS: 1003,
+    GENERIC: 1004,
+    ACCESS_TOKEN: 2001,
+    REFRESH_TOKEN: 2002,
+    ID_TOKEN: 2003,
+    APP_METADATA: 3001,
+    UNDEFINED: 9999,
+} as const;
+export type CacheType = (typeof CacheType)[keyof typeof CacheType];
+
+/**
+ * More Cache related constants
+ */
+export const APP_METADATA = "appmetadata";
+export const CLIENT_INFO = "client_info";
+export const THE_FAMILY_ID = "1";
+
+export const AUTHORITY_METADATA_CONSTANTS = {
+    CACHE_KEY: "authority-metadata",
+    REFRESH_TIME_SECONDS: 3600 * 24, // 24 Hours
+};
+
+export const AuthorityMetadataSource = {
+    CONFIG: "config",
+    CACHE: "cache",
+    NETWORK: "network",
+    HARDCODED_VALUES: "hardcoded_values",
+} as const;
+export type AuthorityMetadataSource =
+    (typeof AuthorityMetadataSource)[keyof typeof AuthorityMetadataSource];
+
+export const SERVER_TELEM_CONSTANTS = {
+    SCHEMA_VERSION: 5,
+    MAX_CUR_HEADER_BYTES: 80, // ESTS limit is 100B, set to 80 to provide a 20B buffer
+    MAX_LAST_HEADER_BYTES: 330, // ESTS limit is 350B, set to 330 to provide a 20B buffer,
+    MAX_CACHED_ERRORS: 50, // Limit the number of errors that can be stored to prevent uncontrolled size gains
+    CACHE_KEY: "server-telemetry",
+    CATEGORY_SEPARATOR: "|",
+    VALUE_SEPARATOR: ",",
+    OVERFLOW_TRUE: "1",
+    OVERFLOW_FALSE: "0",
+    UNKNOWN_ERROR: "unknown_error",
+};
+
+/**
+ * Type of the authentication request
+ */
+export const AuthenticationScheme = {
+    BEARER: "Bearer",
+    POP: "pop",
+    SSH: "ssh-cert",
+} as const;
+export type AuthenticationScheme =
+    (typeof AuthenticationScheme)[keyof typeof AuthenticationScheme];
+
+/**
+ * Constants related to throttling
+ */
+export const ThrottlingConstants = {
+    // Default time to throttle RequestThumbprint in seconds
+    DEFAULT_THROTTLE_TIME_SECONDS: 60,
+    // Default maximum time to throttle in seconds, overrides what the server sends back
+    DEFAULT_MAX_THROTTLE_TIME_SECONDS: 3600,
+    // Prefix for storing throttling entries
+    THROTTLING_PREFIX: "throttling",
+    // Value assigned to the x-ms-lib-capability header to indicate to the server the library supports throttling
+    X_MS_LIB_CAPABILITY_VALUE: "retry-after, h429",
+};
+
+export const Errors = {
+    INVALID_GRANT_ERROR: "invalid_grant",
+    CLIENT_MISMATCH_ERROR: "client_mismatch",
+};
+
+/**
+ * Password grant parameters
+ */
+export const PasswordGrantConstants = {
+    username: "username",
+    password: "password",
+} as const;
+export type PasswordGrantConstants =
+    (typeof PasswordGrantConstants)[keyof typeof PasswordGrantConstants];
+
+/**
+ * Response codes
+ */
+export const ResponseCodes = {
+    httpSuccess: 200,
+    httpBadRequest: 400,
+} as const;
+export type ResponseCodes = (typeof ResponseCodes)[keyof typeof ResponseCodes];
+
+/**
+ * Region Discovery Sources
+ */
+export const RegionDiscoverySources = {
+    FAILED_AUTO_DETECTION: "1",
+    INTERNAL_CACHE: "2",
+    ENVIRONMENT_VARIABLE: "3",
+    IMDS: "4",
+} as const;
+export type RegionDiscoverySources =
+    (typeof RegionDiscoverySources)[keyof typeof RegionDiscoverySources];
+
+/**
+ * Region Discovery Outcomes
+ */
+export const RegionDiscoveryOutcomes = {
+    CONFIGURED_MATCHES_DETECTED: "1",
+    CONFIGURED_NO_AUTO_DETECTION: "2",
+    CONFIGURED_NOT_DETECTED: "3",
+    AUTO_DETECTION_REQUESTED_SUCCESSFUL: "4",
+    AUTO_DETECTION_REQUESTED_FAILED: "5",
+} as const;
+export type RegionDiscoveryOutcomes =
+    (typeof RegionDiscoveryOutcomes)[keyof typeof RegionDiscoveryOutcomes];
+
+export const CacheOutcome = {
+    NO_CACHE_HIT: "0",
+    FORCE_REFRESH: "1",
+    NO_CACHED_ACCESS_TOKEN: "2",
+    CACHED_ACCESS_TOKEN_EXPIRED: "3",
+    REFRESH_CACHED_ACCESS_TOKEN: "4",
+} as const;
+export type CacheOutcome = (typeof CacheOutcome)[keyof typeof CacheOutcome];
+
+export const JsonTypes = {
+    Jwt: "JWT",
+    Jwk: "JWK",
+    Pop: "pop",
+} as const;
+export type JsonTypes = (typeof JsonTypes)[keyof typeof JsonTypes];
+
+export const ONE_DAY_IN_MS = 86400000;

package/src/utils/FunctionWrappers.ts

@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { Logger } from "../logger/Logger";
+import { IPerformanceClient } from "../telemetry/performance/IPerformanceClient";
+
+/**
+ * Wraps a function with a performance measurement.
+ * Usage: invoke(functionToCall, performanceClient, "EventName", "correlationId")(...argsToPassToFunction)
+ * @param callback
+ * @param eventName
+ * @param logger
+ * @param telemetryClient
+ * @param correlationId
+ * @returns
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const invoke = <T extends Array<any>, U>(
+    callback: (...args: T) => U,
+    eventName: string,
+    logger: Logger,
+    telemetryClient?: IPerformanceClient,
+    correlationId?: string
+) => {
+    return (...args: T): U => {
+        logger.trace(`Executing function ${eventName}`);
+        const inProgressEvent = telemetryClient?.startMeasurement(
+            eventName,
+            correlationId
+        );
+        telemetryClient?.setPreQueueTime(eventName, correlationId);
+        try {
+            const result = callback(...args);
+            inProgressEvent?.end({
+                success: true,
+            });
+            logger.trace(`Returning result from ${eventName}`);
+            return result;
+        } catch (e) {
+            logger.trace(`Error occurred in ${eventName}`);
+            try {
+                logger.trace(JSON.stringify(e));
+            } catch (e) {
+                logger.trace("Unable to print error message.");
+            }
+            inProgressEvent?.end({
+                success: false,
+            });
+            throw e;
+        }
+    };
+};
+
+/**
+ * Wraps an async function with a performance measurement.
+ * Usage: invokeAsync(functionToCall, performanceClient, "EventName", "correlationId")(...argsToPassToFunction)
+ * @param callback
+ * @param eventName
+ * @param logger
+ * @param telemetryClient
+ * @param correlationId
+ * @returns
+ * @internal
+ *
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const invokeAsync = <T extends Array<any>, U>(
+    callback: (...args: T) => Promise<U>,
+    eventName: string,
+    logger: Logger,
+    telemetryClient?: IPerformanceClient,
+    correlationId?: string
+) => {
+    return (...args: T): Promise<U> => {
+        logger.trace(`Executing function ${eventName}`);
+        const inProgressEvent = telemetryClient?.startMeasurement(
+            eventName,
+            correlationId
+        );
+        telemetryClient?.setPreQueueTime(eventName, correlationId);
+        return callback(...args)
+            .then((response) => {
+                logger.trace(`Returning result from ${eventName}`);
+                inProgressEvent?.end({
+                    success: true,
+                });
+                return response;
+            })
+            .catch((e) => {
+                logger.trace(`Error occurred in ${eventName}`);
+                try {
+                    logger.trace(JSON.stringify(e));
+                } catch (e) {
+                    logger.trace("Unable to print error message.");
+                }
+                inProgressEvent?.end({
+                    success: false,
+                });
+                throw e;
+            });
+    };
+};

package/src/utils/MsalTypes.ts

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * Key-Value type to support queryParams, extraQueryParams and claims
+ */
+export type StringDict = { [key: string]: string };

package/src/utils/ProtocolUtils.ts

@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { Constants } from "./Constants";
+import { ICrypto } from "../crypto/ICrypto";
+import { ClientAuthError } from "../error/ClientAuthError";
+
+/**
+ * Type which defines the object that is stringified, encoded and sent in the state value.
+ * Contains the following:
+ * - id - unique identifier for this request
+ * - ts - timestamp for the time the request was made. Used to ensure that token expiration is not calculated incorrectly.
+ * - platformState - string value sent from the platform.
+ */
+export type LibraryStateObject = {
+    id: string;
+    meta?: Record<string, string>;
+};
+
+/**
+ * Type which defines the stringified and encoded object sent to the service in the authorize request.
+ */
+export type RequestStateObject = {
+    userRequestState: string;
+    libraryState: LibraryStateObject;
+};
+
+/**
+ * Class which provides helpers for OAuth 2.0 protocol specific values
+ */
+export class ProtocolUtils {
+    /**
+     * Appends user state with random guid, or returns random guid.
+     * @param userState
+     * @param randomGuid
+     */
+    static setRequestState(
+        cryptoObj: ICrypto,
+        userState?: string,
+        meta?: Record<string, string>
+    ): string {
+        const libraryState = ProtocolUtils.generateLibraryState(
+            cryptoObj,
+            meta
+        );
+        return userState
+            ? `${libraryState}${Constants.RESOURCE_DELIM}${userState}`
+            : libraryState;
+    }
+
+    /**
+     * Generates the state value used by the common library.
+     * @param randomGuid
+     * @param cryptoObj
+     */
+    static generateLibraryState(
+        cryptoObj: ICrypto,
+        meta?: Record<string, string>
+    ): string {
+        if (!cryptoObj) {
+            throw ClientAuthError.createNoCryptoObjectError(
+                "generateLibraryState"
+            );
+        }
+
+        // Create a state object containing a unique id and the timestamp of the request creation
+        const stateObj: LibraryStateObject = {
+            id: cryptoObj.createNewGuid(),
+        };
+
+        if (meta) {
+            stateObj.meta = meta;
+        }
+
+        const stateString = JSON.stringify(stateObj);
+
+        return cryptoObj.base64Encode(stateString);
+    }
+
+    /**
+     * Parses the state into the RequestStateObject, which contains the LibraryState info and the state passed by the user.
+     * @param state
+     * @param cryptoObj
+     */
+    static parseRequestState(
+        cryptoObj: ICrypto,
+        state: string
+    ): RequestStateObject {
+        if (!cryptoObj) {
+            throw ClientAuthError.createNoCryptoObjectError(
+                "parseRequestState"
+            );
+        }
+
+        if (!state) {
+            throw ClientAuthError.createInvalidStateError(
+                state,
+                "Null, undefined or empty state"
+            );
+        }
+
+        try {
+            // Split the state between library state and user passed state and decode them separately
+            const splitState = state.split(Constants.RESOURCE_DELIM);
+            const libraryState = splitState[0];
+            const userState =
+                splitState.length > 1
+                    ? splitState.slice(1).join(Constants.RESOURCE_DELIM)
+                    : Constants.EMPTY_STRING;
+            const libraryStateString = cryptoObj.base64Decode(libraryState);
+            const libraryStateObj = JSON.parse(
+                libraryStateString
+            ) as LibraryStateObject;
+            return {
+                userRequestState: userState || Constants.EMPTY_STRING,
+                libraryState: libraryStateObj,
+            };
+        } catch (e) {
+            throw ClientAuthError.createInvalidStateError(state, e as string);
+        }
+    }
+}