@sudoplatform/sudo-user 11.0.0 → 12.0.0

package/lib/src/user/user-client-interface.d.ts

@@ -0,0 +1,168 @@
+import { SudoKeyManager } from '@sudoplatform/sudo-common';
+import { AuthenticationProvider } from './auth-provider';
+/**
+ * Encapsulates the authentication tokens obtained from a successful authentication.
+ *
+ * @param idToken ID token containing the user's identity attributes.
+ * @param accessToken access token required for authorizing API access.
+ * @param refreshToken refresh token used for refreshing ID and access tokens.
+ * @param tokenExpiry expiry of ID and access tokens in milliseconds.
+ */
+export interface AuthenticationTokens {
+    idToken: string;
+    accessToken: string;
+    refreshToken: string;
+    tokenExpiry: number;
+}
+/**
+ * Interface encapsulating a library of functions for calling Sudo Platform identity service,
+ * handling federated sign in, managing keys and performing cryptographic operations.
+ */
+export interface SudoUserClient {
+    /**
+     * Presents the sign in UI for federated sign in using an external identity provider.
+     */
+    presentFederatedSignInUI(): void;
+    /**
+     * Processes tokens from federated sign in returned to the specified URL.
+     * The tokens are passed to the web app via a redirect URL.
+     *
+     * @param url callback URL containing the tokens.
+     * @return Successful authentication result AuthenticationTokens.
+     */
+    processFederatedSignInTokens(url: string): Promise<AuthenticationTokens>;
+    /**
+     * Returns the ID token cached from the last sign-in.
+     *
+     * @return ID token.
+     */
+    getIdToken(): Promise<string | undefined>;
+    /**
+     * Returns the access token cached from the last sign-in.
+     *
+     * @return access token.
+     */
+    getAccessToken(): Promise<string | undefined>;
+    /**
+     * Returns the refresh token cached from the last sign-in.
+     *
+     * @return refresh token.
+     */
+    getRefreshToken(): Promise<string | undefined>;
+    /**
+     * Returns the ID and access token expiry cached from the last sign-in.
+     *
+     * @return token expiry.
+     */
+    getTokenExpiry(): Promise<Date | undefined>;
+    /**
+     * Returns the refresh token expiry cached from the last sign-in.
+     *
+     * @return refresh token expiry.
+     */
+    getRefreshTokenExpiry(): Promise<Date | undefined>;
+    /**
+     * Indicates whether or not this client is signed in with Sudo Platform backend. The client is
+     * considered signed in if it cached valid ID, access and refresh tokens.
+     *
+     * @return *true* if the client is signed in.
+     */
+    isSignedIn(): Promise<boolean>;
+    /**
+     * Refresh the access and ID tokens using the refresh token.
+     *
+     * @param refreshToken refresh token used to refresh the access and ID tokens.
+     * @return Successful authentication result AuthenticationTokens containing refreshed tokens
+     */
+    refreshTokens(refreshToken: string): Promise<AuthenticationTokens>;
+    /**
+     * Retrieves the latest ID token. This is to be used by the AWS AppSync client.
+     *
+     * @returns the latest ID token
+     */
+    getLatestAuthToken(): Promise<string>;
+    /**
+     * Returns the user name associated with this client. The username maybe needed to contact
+     * the support team when diagnosing an issue related to a specific user.
+     *
+     * @return user name.
+     */
+    getUserName(): Promise<string | undefined>;
+    /**
+     * Sets the user name associated with this client.
+     *
+     * @param name user name.
+     */
+    setUserName(name: string): Promise<void>;
+    /**
+     * Returns the subject of the user associated with this client.
+     * Note: This is an internal method used by other Sudo platform SDKs.
+     *
+     * @return user subject.
+     */
+    getSubject(): Promise<string | undefined>;
+    /**
+     * Returns the specified claim associated with the user's identity.
+     *
+     * @param name claim name.
+     */
+    getUserClaim(name: string): Promise<any | undefined>;
+    /**
+     * Signs out the user from this device.
+     */
+    signOut(): Promise<void>;
+    /**
+     * Signs out the user from all devices.
+     */
+    globalSignOut(): Promise<void>;
+    /**
+     * Registers this client against the backend with an external authentication provider. The caller must
+     * implement AuthenticationProvider protocol to return the appropriate authentication token required
+     * to authorize the registration request.
+     *
+     * @param authenticationProvider authentication provider that provides the authentication token.
+     * @param registrationId registration ID to uniquely identify this registration request.
+     * @return user ID of the newly created user
+     */
+    registerWithAuthenticationProvider(authenticationProvider: AuthenticationProvider, registrationId?: string): Promise<string>;
+    /**
+     * Sign into the backend using an external authentication provider. Caller must implement
+     * *AuthenticationProvider* interface to return the appropriate authentication token associated with
+     * the external identity registered with *registerWithAuthenticationProvider*.
+     *
+     * @param authenticationProvider authentication provider that provides the authentication token.
+     * @return authentication tokens associated with the successful sign in.
+     */
+    signInWithAuthenticationProvider(authenticationProvider: AuthenticationProvider): Promise<AuthenticationTokens>;
+    /**
+     * Indicates whether or not this client is registered with Sudo Platform backend.
+     *
+     * @return *true* if the client is registered.
+     */
+    isRegistered(): Promise<boolean>;
+    /**
+     * Sign into the backend using a private key. The client must have created a private/public key pair via
+     * the *registerWithAuthenticationProvider* method.
+     *
+     * @return authentication tokens associated with the successful sign in.
+     */
+    signInWithKey(): Promise<AuthenticationTokens>;
+    /**
+     * Clears cached authentication tokens.
+     */
+    clearAuthenticationTokens(): Promise<void>;
+    /**
+     * Presents the Cognito hosted UI signout endpoint.
+     * When the endpoint is invoked, the hosted web app's cookies
+     * will be invalidated, but the user is not logged out of Cognito.
+     */
+    presentSignOutUI(): void;
+    /**
+     * Resets internal state and clears any cached data.
+     */
+    reset(): void;
+    /**
+     * Getter to retrieve the SudoKeyManager
+     */
+    readonly sudoKeyManager: SudoKeyManager;
+}

package/lib/src/user/user-client-interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=user-client-interface.js.map

package/lib/src/user/user-client-interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-client-interface.js","sourceRoot":"","sources":["../../../src/user/user-client-interface.ts"],"names":[],"mappings":""}

package/lib/src/user/user-client.d.ts

@@ -0,0 +1,82 @@
+import { Logger, SudoKeyManager } from '@sudoplatform/sudo-common';
+import { AuthenticationProvider } from '..';
+import { ApiClient } from '../client/apiClient';
+import { AuthenticationStore } from '../core/auth-store';
+import { Config } from '../core/sdk-config';
+import { AuthUI } from './auth';
+import { IdentityProvider } from './identity-provider';
+import { AuthenticationTokens, SudoUserClient } from './user-client-interface';
+export interface SudoUserOptions {
+    authenticationStore?: AuthenticationStore;
+    sudoKeyManager?: SudoKeyManager;
+    apiClient?: ApiClient;
+    authUI?: AuthUI;
+    identityProvider?: IdentityProvider;
+    launchUriFn?: (url: string) => void;
+    config?: Config;
+    logger?: Logger;
+}
+export declare class DefaultSudoUserClient implements SudoUserClient {
+    private config;
+    private keyManager;
+    private sudoUserKeyManager;
+    private authenticationStore;
+    private identityProvider;
+    private apiClient;
+    private logger;
+    private authUI?;
+    private launchUriFn?;
+    constructor(options?: SudoUserOptions);
+    get sudoKeyManager(): SudoKeyManager;
+    presentFederatedSignInUI(): void;
+    processFederatedSignInTokens(url: string): Promise<AuthenticationTokens>;
+    getIdToken(): Promise<string | undefined>;
+    getAccessToken(): Promise<string | undefined>;
+    getRefreshToken(): Promise<string | undefined>;
+    getTokenExpiry(): Promise<Date | undefined>;
+    getRefreshTokenExpiry(): Promise<Date | undefined>;
+    getUserName(): Promise<string | undefined>;
+    setUserName(name: string): Promise<void>;
+    getUserClaim(name: string): Promise<any | undefined>;
+    getSubject(): Promise<string | undefined>;
+    isSignedIn(): Promise<boolean>;
+    refreshTokens(refreshToken: string): Promise<AuthenticationTokens>;
+    getLatestAuthToken(): Promise<string>;
+    signOut(): Promise<void>;
+    globalSignOut(): Promise<void>;
+    registerWithAuthenticationProvider(authenticationProvider: AuthenticationProvider, registrationId?: string): Promise<string>;
+    signInWithAuthenticationProvider(authenticationProvider: AuthenticationProvider): Promise<AuthenticationTokens>;
+    isRegistered(): Promise<boolean>;
+    signInWithKey(): Promise<AuthenticationTokens>;
+    deregister(): Promise<void>;
+    clearAuthenticationTokens(): Promise<void>;
+    presentSignOutUI(): void;
+    reset(): void;
+    private getTokenClaim;
+    /**
+     * Store the authentication tokens and user id of the signed in user. This function
+     * is only called when a user has successfully signed in using a private key.
+     */
+    private storeTokens;
+    private registerFederatedIdAndRefreshTokens;
+    private generateRegistrationData;
+    private getAuthTokens;
+    /**
+     * Provide a custom auth UI. This is mainly used for unit testing (optional).
+     */
+    setAuthUI(authUI: AuthUI): void;
+    /**
+     * Provide a custom identity provider. This is mainly used for unit testing (optional).
+     */
+    setIdentityProvider(identityProvider: IdentityProvider): void;
+    /**
+     * Provide a custom function to open the sign in url.
+     * This is mainly used for unit testing (optional).
+     */
+    setLaunchUriFn(launchUriFn: (url: string) => void): void;
+    /**
+     * Provide a custom authentication store.
+     * This is mainly used for unit testing (optional).
+     */
+    setAuthenticationStore(authenticationStore: AuthenticationStore): void;
+}

package/lib/src/user/user-client.js

@@ -0,0 +1,435 @@
+import { AuthenticationError, DefaultLogger, DefaultSudoKeyManager, FatalError, KeyNotFoundError, NotAuthorizedError, NotRegisteredError, NotSignedInError, PublicKeyFormat, RegisterError, } from '@sudoplatform/sudo-common';
+import { WebSudoCryptoProvider } from '@sudoplatform/sudo-web-crypto-provider';
+import * as JWT from 'jsonwebtoken';
+import { v4 } from 'uuid';
+import { ApiClient } from '../client/apiClient';
+import { apiKeyNames } from '../core/api-key-names';
+import { AuthenticationStore } from '../core/auth-store';
+import { KeyManager } from '../core/key-manager';
+import { getIdentityServiceConfig } from '../core/sdk-config';
+import { CognitoAuthUI } from './auth';
+import { AlreadyRegisteredError } from './error';
+import { CognitoUserPoolIdentityProvider, } from './identity-provider';
+import { userKeyNames } from './user-key-names';
+export class DefaultSudoUserClient {
+    constructor(options) {
+        this.logger = options?.logger ?? new DefaultLogger('SudoUser', 'warn');
+        this.config = options?.config ?? getIdentityServiceConfig();
+        this.authenticationStore =
+            options?.authenticationStore ?? new AuthenticationStore();
+        if (options?.sudoKeyManager) {
+            this.sudoUserKeyManager = options?.sudoKeyManager;
+        }
+        else {
+            const cryptoProvider = new WebSudoCryptoProvider('SudoUserClient', 'com.sudoplatform.appservicename');
+            this.sudoUserKeyManager = new DefaultSudoKeyManager(cryptoProvider);
+        }
+        this.keyManager = new KeyManager(this.sudoUserKeyManager);
+        this.launchUriFn = options?.launchUriFn;
+        this.identityProvider =
+            options?.identityProvider ??
+                new CognitoUserPoolIdentityProvider(this.keyManager, this.config, this.logger);
+        const federatedSignInConfig = this.config?.federatedSignIn;
+        if (federatedSignInConfig) {
+            this.authUI =
+                options?.authUI ??
+                    new CognitoAuthUI(this.authenticationStore, federatedSignInConfig, this.keyManager, this.logger, this.launchUriFn);
+        }
+        this.apiClient =
+            options?.apiClient ??
+                new ApiClient(this.config.identityService.region, this.config.identityService.apiUrl, this, this.logger);
+    }
+    get sudoKeyManager() {
+        return this.sudoUserKeyManager;
+    }
+    presentFederatedSignInUI() {
+        try {
+            this.authUI?.presentFederatedSignInUI();
+        }
+        catch (err) {
+            const error = err;
+            this.logger.error('Failed to launch the federated sign in UI.', { error });
+            throw new AuthenticationError(error.message);
+        }
+    }
+    async processFederatedSignInTokens(url) {
+        try {
+            let authTokens = await this.authUI?.processFederatedSignInTokens(url);
+            if (authTokens) {
+                authTokens = await this.registerFederatedIdAndRefreshTokens(authTokens);
+                return authTokens;
+            }
+            else {
+                throw new AuthenticationError('Authentication tokens missing.');
+            }
+        }
+        catch (err) {
+            const error = err;
+            this.logger.error('Failed to process the federated sign in redirect.', {
+                error,
+            });
+            throw new AuthenticationError(error.message);
+        }
+    }
+    async getIdToken() {
+        return await this.keyManager.getString(apiKeyNames.idToken);
+    }
+    async getAccessToken() {
+        return await this.keyManager.getString(apiKeyNames.accessToken);
+    }
+    async getRefreshToken() {
+        return await this.keyManager.getString(apiKeyNames.refreshToken);
+    }
+    async getTokenExpiry() {
+        const expiry = await this.keyManager.getString(apiKeyNames.tokenExpiry);
+        return expiry ? new Date(Number(expiry) * 1000) : undefined;
+    }
+    async getRefreshTokenExpiry() {
+        let expiry = undefined;
+        const timeSinceEpoch = await this.keyManager.getString(apiKeyNames.refreshTokenExpiry);
+        if (timeSinceEpoch) {
+            expiry = new Date(Number(timeSinceEpoch));
+        }
+        return expiry;
+    }
+    async getUserName() {
+        try {
+            return await this.keyManager.getString(userKeyNames.userId);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async setUserName(name) {
+        await this.keyManager.removeItem(userKeyNames.userId);
+        await this.keyManager.addString(userKeyNames.userId, name);
+    }
+    async getUserClaim(name) {
+        const idToken = await this.getIdToken();
+        if (!idToken)
+            return undefined;
+        return this.getTokenClaim(idToken, name);
+    }
+    async getSubject() {
+        return await this.getUserClaim('sub');
+    }
+    async isSignedIn() {
+        try {
+            const authTokens = await this.getAuthTokens();
+            const expiry = await this.getRefreshTokenExpiry();
+            if (authTokens &&
+                authTokens.idToken &&
+                authTokens.accessToken &&
+                authTokens.refreshToken &&
+                expiry &&
+                // Considered signed in up to 1 hour before the expiry of refresh token.
+                expiry.getTime() > new Date().getTime() + 60 * 60 * 1000) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+        catch (err) {
+            // The key manager throws a KeyNotFoundError if an item is not found
+            // in which case we want to indicate that the user is not signed in.
+            return false;
+        }
+    }
+    async refreshTokens(refreshToken) {
+        try {
+            const uid = await this.getUserName();
+            if (uid) {
+                const authTokens = await this.identityProvider.refreshTokens(refreshToken);
+                await this.storeTokens(uid, authTokens);
+                return authTokens;
+            }
+            else {
+                throw new NotRegisteredError('Not registered.');
+            }
+        }
+        catch (err) {
+            const error = err;
+            throw new AuthenticationError(error.message);
+        }
+    }
+    async getLatestAuthToken() {
+        try {
+            const idToken = await this.getIdToken();
+            const refreshToken = await this.getRefreshToken();
+            const expiry = await this.getTokenExpiry();
+            if (idToken && refreshToken && expiry) {
+                if (expiry.getTime() > new Date().getTime() + 600 * 1000) {
+                    return idToken;
+                }
+                else {
+                    try {
+                        const authTokens = await this.refreshTokens(refreshToken);
+                        return authTokens.idToken;
+                    }
+                    catch (error) {
+                        this.logger.info('getLatestAuthToken: Token refresh failed', {
+                            error,
+                        });
+                        // return an empty id token
+                        return '';
+                    }
+                }
+            }
+            else {
+                // If tokens are missing then it's likely due to the client not being signed in.
+                // Return an empty id token.
+                return '';
+            }
+        }
+        catch (err) {
+            // The key manager throws a KeyNotFoundError if an item is not found
+            // which would indicate that the client is likely not signed in.
+            // Return an empty id token.
+            return '';
+        }
+    }
+    async signOut() {
+        let refreshToken;
+        try {
+            refreshToken = await this.getRefreshToken();
+        }
+        catch (err) {
+            if (err instanceof KeyNotFoundError) {
+                throw new NotSignedInError();
+            }
+            else {
+                throw err;
+            }
+        }
+        if (refreshToken) {
+            await this.identityProvider.signOut(refreshToken);
+        }
+        else {
+            throw new NotSignedInError();
+        }
+    }
+    async globalSignOut() {
+        if (!(await this.isSignedIn())) {
+            throw new NotSignedInError();
+        }
+        await this.apiClient.globalSignOut();
+        this.clearAuthenticationTokens();
+    }
+    async registerWithAuthenticationProvider(authenticationProvider, registrationId) {
+        this.logger.info('Registering using an external authentication provider.');
+        if (!(await this.isRegistered())) {
+            const authInfo = await authenticationProvider.getAuthenticationInfo();
+            if (!authInfo.isValid()) {
+                throw new NotAuthorizedError('Authentication provider returned invalid authentication info.');
+            }
+            const token = authInfo.encode();
+            const jwt = JWT.decode(token, { complete: true });
+            let uid;
+            if (jwt && jwt.payload['sub']) {
+                uid = jwt.payload['sub'];
+            }
+            else {
+                uid = v4();
+            }
+            const publicKey = await this.generateRegistrationData();
+            const data = {
+                challengeType: authInfo.type,
+                answer: token,
+                registrationId: registrationId ? registrationId : v4(),
+                publicKey: JSON.stringify(publicKeyToRSAPublicKey(publicKey)),
+            };
+            const validationData = Object.keys(data).map((key) => {
+                return {
+                    Name: key,
+                    Value: data[key],
+                };
+            });
+            const userId = await this.identityProvider.register(uid, validationData);
+            if (userId) {
+                await this.setUserName(userId);
+                return userId;
+            }
+            else {
+                throw new RegisterError('Registration was successful but not user ID was returned.');
+            }
+        }
+        else {
+            throw new AlreadyRegisteredError();
+        }
+    }
+    async signInWithAuthenticationProvider(authenticationProvider) {
+        this.logger.info('Signing in using external authentication provider.');
+        const authInfo = await authenticationProvider.getAuthenticationInfo();
+        if (!authInfo.isValid()) {
+            throw new NotAuthorizedError('Authentication provider returned invalid authentication info.');
+        }
+        const uid = authInfo.getUsername();
+        const token = authInfo.encode();
+        const type = authInfo.type;
+        let authTokens = await this.identityProvider.signInWithToken(uid, token, type);
+        await this.storeTokens(uid, authTokens);
+        authTokens = await this.registerFederatedIdAndRefreshTokens(authTokens);
+        return authTokens;
+    }
+    async isRegistered() {
+        try {
+            const uid = await this.getUserName();
+            return uid ? true : false;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    async signInWithKey() {
+        this.logger.info('Signing in using private key.');
+        const uid = await this.getUserName();
+        const userKeyId = await this.keyManager.getString('userKeyId');
+        if (uid && userKeyId) {
+            let authTokens = await this.identityProvider.signInWithKey(uid, userKeyId);
+            if (authTokens) {
+                await this.storeTokens(uid, authTokens);
+                authTokens = await this.registerFederatedIdAndRefreshTokens(authTokens);
+                return authTokens;
+            }
+            else {
+                throw new FatalError('Unexpected error. Unable to sign in.');
+            }
+        }
+        else {
+            throw new NotRegisteredError('Not registered.');
+        }
+    }
+    async deregister() {
+        await this.apiClient.deregister();
+        await this.keyManager.reset();
+        this.clearAuthenticationTokens();
+    }
+    async clearAuthenticationTokens() {
+        await this.keyManager.removeItem(apiKeyNames.idToken);
+        await this.keyManager.removeItem(apiKeyNames.accessToken);
+        await this.keyManager.removeItem(apiKeyNames.refreshToken);
+        await this.keyManager.removeItem(apiKeyNames.tokenExpiry);
+        this.authenticationStore.reset();
+        if (this.authUI) {
+            this.authUI.reset();
+        }
+    }
+    presentSignOutUI() {
+        this.authUI?.presentSignOutUI();
+    }
+    reset() {
+        this.keyManager.reset();
+        this.apiClient.reset();
+        this.clearAuthenticationTokens();
+    }
+    getTokenClaim(token, name) {
+        let claim = undefined;
+        const decoded = JWT.decode(token, { complete: true });
+        if (decoded) {
+            claim = decoded.payload[name];
+        }
+        return claim;
+    }
+    /**
+     * Store the authentication tokens and user id of the signed in user. This function
+     * is only called when a user has successfully signed in using a private key.
+     */
+    async storeTokens(uid, authTokens) {
+        await this.keyManager.removeItem(userKeyNames.userId);
+        await this.keyManager.removeItem(apiKeyNames.idToken);
+        await this.keyManager.removeItem(apiKeyNames.accessToken);
+        await this.keyManager.removeItem(apiKeyNames.refreshToken);
+        await this.keyManager.removeItem(apiKeyNames.tokenExpiry);
+        await this.keyManager.addString(userKeyNames.userId, uid);
+        await this.keyManager.addString(apiKeyNames.idToken, authTokens.idToken);
+        await this.keyManager.addString(apiKeyNames.accessToken, authTokens.accessToken);
+        await this.keyManager.addString(apiKeyNames.refreshToken, authTokens.refreshToken);
+        const decoded = JWT.decode(authTokens.idToken, { complete: true });
+        if (decoded) {
+            const tokenExpiry = decoded.payload['exp'];
+            await this.keyManager.addString(apiKeyNames.tokenExpiry, tokenExpiry);
+        }
+    }
+    async registerFederatedIdAndRefreshTokens(authTokens) {
+        const identityId = this.getTokenClaim(authTokens.idToken, 'custom:identityId');
+        if (identityId) {
+            return authTokens;
+        }
+        else {
+            await this.apiClient.registerFederatedId({
+                idToken: authTokens.idToken,
+            });
+            // Refresh the ID token so the identity ID is present as a claim.
+            const newAuthTokens = await this.refreshTokens(authTokens.refreshToken);
+            return newAuthTokens;
+        }
+    }
+    async generateRegistrationData() {
+        const keyId = await this.keyManager.generateKeyPair();
+        await this.keyManager.removeItem(userKeyNames.userKeyId);
+        await this.keyManager.addString(userKeyNames.userKeyId, keyId);
+        const publicKey = await this.keyManager.exportPublicKey(keyId);
+        return publicKey;
+    }
+    async getAuthTokens() {
+        const idToken = await this.getIdToken();
+        const accessToken = await this.getAccessToken();
+        const refreshToken = await this.getRefreshToken();
+        const tokenExpiry = await this.getTokenExpiry();
+        if (idToken && accessToken && refreshToken && tokenExpiry) {
+            return {
+                idToken: idToken,
+                accessToken: accessToken,
+                refreshToken: refreshToken,
+                tokenExpiry: tokenExpiry.getTime(),
+            };
+        }
+        else {
+            return undefined;
+        }
+    }
+    /**
+     * Provide a custom auth UI. This is mainly used for unit testing (optional).
+     */
+    setAuthUI(authUI) {
+        this.authUI = authUI;
+    }
+    /**
+     * Provide a custom identity provider. This is mainly used for unit testing (optional).
+     */
+    setIdentityProvider(identityProvider) {
+        this.identityProvider = identityProvider;
+    }
+    /**
+     * Provide a custom function to open the sign in url.
+     * This is mainly used for unit testing (optional).
+     */
+    setLaunchUriFn(launchUriFn) {
+        this.launchUriFn = launchUriFn;
+    }
+    /**
+     * Provide a custom authentication store.
+     * This is mainly used for unit testing (optional).
+     */
+    setAuthenticationStore(authenticationStore) {
+        this.authenticationStore = authenticationStore;
+    }
+}
+/**
+ * Convert PublicKey of any format to an RSAPublicKey format public key
+ *
+ * @param publicKey PublicKey to convert
+ * @returns RSAPublicKey formatted PublicKey
+ */
+function publicKeyToRSAPublicKey(publicKey) {
+    if (publicKey.keyFormat === PublicKeyFormat.RSAPublicKey) {
+        return publicKey;
+    }
+    return {
+        ...publicKey,
+        publicKey: publicKey.publicKey.replace('MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A', ''),
+        keyFormat: PublicKeyFormat.RSAPublicKey,
+    };
+}
+//# sourceMappingURL=user-client.js.map