@openfort/openfort-js 0.7.6 → 0.7.8

package/dist/index.cjs

@@ -1034,15 +1034,15 @@ const AuthenticationApiAxiosParamCreator = function (configuration) {
         },
         /**
          *
-         * @summary Initialize Link OAuth.
+         * @summary Initialize OAuth.
          * @param {OAuthInitRequest} oAuthInitRequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        initLinkOAuth: async (oAuthInitRequest, options = {}) => {
+        initOAuth: async (oAuthInitRequest, options = {}) => {
             // verify required parameter 'oAuthInitRequest' is not null or undefined
-            assertParamExists('initLinkOAuth', 'oAuthInitRequest', oAuthInitRequest);
-            const localVarPath = `/iam/v1/oauth/init_link`;
+            assertParamExists('initOAuth', 'oAuthInitRequest', oAuthInitRequest);
+            const localVarPath = `/iam/v1/oauth/init`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -1052,6 +1052,9 @@ const AuthenticationApiAxiosParamCreator = function (configuration) {
             const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
+            // authentication pk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
             localVarHeaderParameter['Content-Type'] = 'application/json';
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
@@ -1063,16 +1066,16 @@ const AuthenticationApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         *
-         * @summary Initialize OAuth.
-         * @param {OAuthInitRequest} oAuthInitRequest
+         * Create a challenge to link external wallet to the player.
+         * @summary Initialize SIWE.
+         * @param {SIWERequest} sIWERequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        initOAuth: async (oAuthInitRequest, options = {}) => {
-            // verify required parameter 'oAuthInitRequest' is not null or undefined
-            assertParamExists('initOAuth', 'oAuthInitRequest', oAuthInitRequest);
-            const localVarPath = `/iam/v1/oauth/init`;
+        initSIWE: async (sIWERequest, options = {}) => {
+            // verify required parameter 'sIWERequest' is not null or undefined
+            assertParamExists('initSIWE', 'sIWERequest', sIWERequest);
+            const localVarPath = `/iam/v1/siwe/init`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -1089,23 +1092,22 @@ const AuthenticationApiAxiosParamCreator = function (configuration) {
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            localVarRequestOptions.data = serializeDataIfNeeded(oAuthInitRequest, localVarRequestOptions, configuration);
+            localVarRequestOptions.data = serializeDataIfNeeded(sIWERequest, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
             };
         },
         /**
-         * Create a challenge to link external wallet to the player.
-         * @summary Initialize SIWE.
-         * @param {SIWERequest} sIWERequest
+         *
+         * @param {LoginRequest} loginRequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        initSIWE: async (sIWERequest, options = {}) => {
-            // verify required parameter 'sIWERequest' is not null or undefined
-            assertParamExists('initSIWE', 'sIWERequest', sIWERequest);
-            const localVarPath = `/iam/v1/siwe/init`;
+        linkEmail: async (loginRequest, options = {}) => {
+            // verify required parameter 'loginRequest' is not null or undefined
+            assertParamExists('linkEmail', 'loginRequest', loginRequest);
+            const localVarPath = `/iam/v1/password/link`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -1115,14 +1117,41 @@ const AuthenticationApiAxiosParamCreator = function (configuration) {
             const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
-            // authentication pk required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
             localVarHeaderParameter['Content-Type'] = 'application/json';
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            localVarRequestOptions.data = serializeDataIfNeeded(sIWERequest, localVarRequestOptions, configuration);
+            localVarRequestOptions.data = serializeDataIfNeeded(loginRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         *
+         * @summary Initialize Link OAuth.
+         * @param {OAuthInitRequest} oAuthInitRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        linkOAuth: async (oAuthInitRequest, options = {}) => {
+            // verify required parameter 'oAuthInitRequest' is not null or undefined
+            assertParamExists('linkOAuth', 'oAuthInitRequest', oAuthInitRequest);
+            const localVarPath = `/iam/v1/oauth/init_link`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(oAuthInitRequest, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
@@ -1319,7 +1348,7 @@ const AuthenticationApiAxiosParamCreator = function (configuration) {
         requestEmailVerification: async (requestVerifyEmailRequest, options = {}) => {
             // verify required parameter 'requestVerifyEmailRequest' is not null or undefined
             assertParamExists('requestEmailVerification', 'requestVerifyEmailRequest', requestVerifyEmailRequest);
-            const localVarPath = `/iam/v1/password/email/request_verification`;
+            const localVarPath = `/iam/v1/password/request_email_verification`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -1352,7 +1381,7 @@ const AuthenticationApiAxiosParamCreator = function (configuration) {
         requestResetPassword: async (requestResetPasswordRequest, options = {}) => {
             // verify required parameter 'requestResetPasswordRequest' is not null or undefined
             assertParamExists('requestResetPassword', 'requestResetPasswordRequest', requestResetPasswordRequest);
-            const localVarPath = `/iam/v1/password/password/request_reset`;
+            const localVarPath = `/iam/v1/password/request_reset`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -1385,7 +1414,7 @@ const AuthenticationApiAxiosParamCreator = function (configuration) {
         resetPassword: async (resetPasswordRequest, options = {}) => {
             // verify required parameter 'resetPasswordRequest' is not null or undefined
             assertParamExists('resetPassword', 'resetPasswordRequest', resetPasswordRequest);
-            const localVarPath = `/iam/v1/password/password/reset`;
+            const localVarPath = `/iam/v1/password/reset`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -1474,16 +1503,45 @@ const AuthenticationApiAxiosParamCreator = function (configuration) {
                 options: localVarRequestOptions,
             };
         },
+        /**
+         *
+         * @param {UnlinkEmailRequest} unlinkEmailRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        unlinkEmail: async (unlinkEmailRequest, options = {}) => {
+            // verify required parameter 'unlinkEmailRequest' is not null or undefined
+            assertParamExists('unlinkEmail', 'unlinkEmailRequest', unlinkEmailRequest);
+            const localVarPath = `/iam/v1/password/unlink`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(unlinkEmailRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          *
          * @summary Unlink OAuth account
-         * @param {UnlinkRequest} unlinkRequest
+         * @param {UnlinkOAuthRequest} unlinkOAuthRequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        unlinkOAuth: async (unlinkRequest, options = {}) => {
-            // verify required parameter 'unlinkRequest' is not null or undefined
-            assertParamExists('unlinkOAuth', 'unlinkRequest', unlinkRequest);
+        unlinkOAuth: async (unlinkOAuthRequest, options = {}) => {
+            // verify required parameter 'unlinkOAuthRequest' is not null or undefined
+            assertParamExists('unlinkOAuth', 'unlinkOAuthRequest', unlinkOAuthRequest);
             const localVarPath = `/iam/v1/oauth/unlink`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -1498,7 +1556,7 @@ const AuthenticationApiAxiosParamCreator = function (configuration) {
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            localVarRequestOptions.data = serializeDataIfNeeded(unlinkRequest, localVarRequestOptions, configuration);
+            localVarRequestOptions.data = serializeDataIfNeeded(unlinkOAuthRequest, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
@@ -1544,7 +1602,7 @@ const AuthenticationApiAxiosParamCreator = function (configuration) {
         verifyEmail: async (verifyEmailRequest, options = {}) => {
             // verify required parameter 'verifyEmailRequest' is not null or undefined
             assertParamExists('verifyEmail', 'verifyEmailRequest', verifyEmailRequest);
-            const localVarPath = `/iam/v1/password/email/verify`;
+            const localVarPath = `/iam/v1/password/verify_email`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -1693,17 +1751,6 @@ const AuthenticationApiFp = function (configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.getJwks(publishableKey, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
-        /**
-         *
-         * @summary Initialize Link OAuth.
-         * @param {OAuthInitRequest} oAuthInitRequest
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async initLinkOAuth(oAuthInitRequest, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.initLinkOAuth(oAuthInitRequest, options);
-            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
-        },
         /**
          *
          * @summary Initialize OAuth.
@@ -1726,6 +1773,27 @@ const AuthenticationApiFp = function (configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.initSIWE(sIWERequest, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         *
+         * @param {LoginRequest} loginRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async linkEmail(loginRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.linkEmail(loginRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         *
+         * @summary Initialize Link OAuth.
+         * @param {OAuthInitRequest} oAuthInitRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async linkOAuth(oAuthInitRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.linkOAuth(oAuthInitRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          *
          * @summary Link external wallet.
@@ -1845,15 +1913,25 @@ const AuthenticationApiFp = function (configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.thirdParty(thirdPartyOAuthRequest, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         *
+         * @param {UnlinkEmailRequest} unlinkEmailRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async unlinkEmail(unlinkEmailRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.unlinkEmail(unlinkEmailRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          *
          * @summary Unlink OAuth account
-         * @param {UnlinkRequest} unlinkRequest
+         * @param {UnlinkOAuthRequest} unlinkOAuthRequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async unlinkOAuth(unlinkRequest, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.unlinkOAuth(unlinkRequest, options);
+        async unlinkOAuth(unlinkOAuthRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.unlinkOAuth(unlinkOAuthRequest, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
         /**
@@ -1956,17 +2034,6 @@ class AuthenticationApi extends BaseAPI {
     getJwks(requestParameters, options) {
         return AuthenticationApiFp(this.configuration).getJwks(requestParameters.publishableKey, options).then((request) => request(this.axios, this.basePath));
     }
-    /**
-     *
-     * @summary Initialize Link OAuth.
-     * @param {AuthenticationApiInitLinkOAuthRequest} requestParameters Request parameters.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof AuthenticationApi
-     */
-    initLinkOAuth(requestParameters, options) {
-        return AuthenticationApiFp(this.configuration).initLinkOAuth(requestParameters.oAuthInitRequest, options).then((request) => request(this.axios, this.basePath));
-    }
     /**
      *
      * @summary Initialize OAuth.
@@ -1989,6 +2056,27 @@ class AuthenticationApi extends BaseAPI {
     initSIWE(requestParameters, options) {
         return AuthenticationApiFp(this.configuration).initSIWE(requestParameters.sIWERequest, options).then((request) => request(this.axios, this.basePath));
     }
+    /**
+     *
+     * @param {AuthenticationApiLinkEmailRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    linkEmail(requestParameters, options) {
+        return AuthenticationApiFp(this.configuration).linkEmail(requestParameters.loginRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     *
+     * @summary Initialize Link OAuth.
+     * @param {AuthenticationApiLinkOAuthRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    linkOAuth(requestParameters, options) {
+        return AuthenticationApiFp(this.configuration).linkOAuth(requestParameters.oAuthInitRequest, options).then((request) => request(this.axios, this.basePath));
+    }
     /**
      *
      * @summary Link external wallet.
@@ -2108,6 +2196,16 @@ class AuthenticationApi extends BaseAPI {
     thirdParty(requestParameters, options) {
         return AuthenticationApiFp(this.configuration).thirdParty(requestParameters.thirdPartyOAuthRequest, options).then((request) => request(this.axios, this.basePath));
     }
+    /**
+     *
+     * @param {AuthenticationApiUnlinkEmailRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    unlinkEmail(requestParameters, options) {
+        return AuthenticationApiFp(this.configuration).unlinkEmail(requestParameters.unlinkEmailRequest, options).then((request) => request(this.axios, this.basePath));
+    }
     /**
      *
      * @summary Unlink OAuth account
@@ -2117,7 +2215,7 @@ class AuthenticationApi extends BaseAPI {
      * @memberof AuthenticationApi
      */
     unlinkOAuth(requestParameters, options) {
-        return AuthenticationApiFp(this.configuration).unlinkOAuth(requestParameters.unlinkRequest, options).then((request) => request(this.axios, this.basePath));
+        return AuthenticationApiFp(this.configuration).unlinkOAuth(requestParameters.unlinkOAuthRequest, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      *
@@ -2996,16 +3094,18 @@ var OpenfortErrorType;
 (function (OpenfortErrorType) {
     OpenfortErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
     OpenfortErrorType["INVALID_CONFIGURATION"] = "INVALID_CONFIGURATION";
-    OpenfortErrorType["WALLET_CONNECTION_ERROR"] = "WALLET_CONNECTION_ERROR";
     OpenfortErrorType["NOT_LOGGED_IN_ERROR"] = "NOT_LOGGED_IN_ERROR";
-    OpenfortErrorType["SILENT_LOGIN_ERROR"] = "SILENT_LOGIN_ERROR";
     OpenfortErrorType["REFRESH_TOKEN_ERROR"] = "REFRESH_TOKEN_ERROR";
     OpenfortErrorType["USER_REGISTRATION_ERROR"] = "USER_REGISTRATION_ERROR";
-    OpenfortErrorType["USER_NOT_REGISTERED_ERROR"] = "USER_NOT_REGISTERED_ERROR";
     OpenfortErrorType["LOGOUT_ERROR"] = "LOGOUT_ERROR";
-    OpenfortErrorType["TRANSFER_ERROR"] = "TRANSFER_ERROR";
     OpenfortErrorType["OPERATION_NOT_SUPPORTED_ERROR"] = "OPERATION_NOT_SUPPORTED_ERROR";
+    OpenfortErrorType["MISSING_SESSION_SIGNER_ERROR"] = "MISSING_SESSION_SIGNER_ERROR";
+    OpenfortErrorType["MISSING_EMBEDDED_SIGNER_ERROR"] = "MISSING_EMBEDDED_SIGNER_ERROR";
+    OpenfortErrorType["MISSING_SIGNER_ERROR"] = "MISSING_SIGNER_ERROR";
 })(OpenfortErrorType || (OpenfortErrorType = {}));
+function isAPIError(error) {
+    return 'code' in error && 'message' in error;
+}
 class OpenfortError extends Error {
     type;
     constructor(message, type) {
@@ -3013,6 +3113,21 @@ class OpenfortError extends Error {
         this.type = type;
     }
 }
+const withOpenfortError = async (fn, customErrorType) => {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        let errorMessage;
+        if (globalAxios.isAxiosError(error) && error.response?.data && isAPIError(error.response.data)) {
+            errorMessage = error.response.data.message;
+        }
+        else {
+            errorMessage = error.message;
+        }
+        throw new OpenfortError(errorMessage, customErrorType);
+    }
+};
 
 const validateConfiguration = (configuration, requiredKeys, prefix) => {
     const missingKeys = requiredKeys
@@ -4567,12 +4682,12 @@ class AuthManager {
         this.backendApiClients = backendApiClients;
         this.instanceManager = instanceManager;
     }
-    async initOAuth(provider, usePooling, options) {
+    async initOAuth(provider, options) {
         const request = {
             oAuthInitRequest: {
                 provider,
                 options,
-                usePooling: usePooling || false,
+                usePooling: options?.usePooling || false,
             },
         };
         const result = await this.backendApiClients.authenticationApi.initOAuth(request);
@@ -4584,26 +4699,6 @@ class AuthManager {
             key: result.data.key,
         };
     }
-    async initLinkOAuth(provider, playerToken, usePooling, options) {
-        const request = {
-            oAuthInitRequest: {
-                provider,
-                options,
-                usePooling: usePooling || false,
-            },
-        };
-        const result = await this.backendApiClients.authenticationApi.initLinkOAuth(request, {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            headers: { 'x-player-token': playerToken },
-        });
-        if (isBrowser() && !options?.skipBrowserRedirect) {
-            window.location.assign(result.data.url);
-        }
-        return {
-            url: result.data.url,
-            key: result.data.key,
-        };
-    }
     async poolOAuth(key) {
         const request = {
             key,
@@ -4636,18 +4731,6 @@ class AuthManager {
         }
         throw new Error('Failed to pool OAuth, try again later');
     }
-    // @deprecated
-    async authenticateOAuth(provider, token, tokenType) {
-        const request = {
-            authenticateOAuthRequest: {
-                provider,
-                token,
-                tokenType,
-            },
-        };
-        const response = await this.backendApiClients.authenticationApi.authenticateOAuth(request);
-        return response.data;
-    }
     async authenticateThirdParty(provider, token, tokenType) {
         const request = {
             thirdPartyOAuthRequest: {
@@ -4656,8 +4739,10 @@ class AuthManager {
                 tokenType,
             },
         };
-        const response = await this.backendApiClients.authenticationApi.thirdParty(request);
-        return response.data;
+        return withOpenfortError(async () => {
+            const response = await this.backendApiClients.authenticationApi.thirdParty(request);
+            return response.data;
+        }, OpenfortErrorType.AUTHENTICATION_ERROR);
     }
     async initSIWE(address) {
         const request = {
@@ -4681,8 +4766,10 @@ class AuthManager {
                 connectorType,
             },
         };
-        const response = await this.backendApiClients.authenticationApi.authenticateSIWE(request);
-        return response.data;
+        return withOpenfortError(async () => {
+            const response = await this.backendApiClients.authenticationApi.authenticateSIWE(request);
+            return response.data;
+        }, OpenfortErrorType.AUTHENTICATION_ERROR);
     }
     async loginEmailPassword(email, password) {
         const request = {
@@ -4691,8 +4778,10 @@ class AuthManager {
                 password,
             },
         };
-        const response = await this.backendApiClients.authenticationApi.loginEmailPassword(request);
-        return response.data;
+        return withOpenfortError(async () => {
+            const response = await this.backendApiClients.authenticationApi.loginEmailPassword(request);
+            return response.data;
+        }, OpenfortErrorType.AUTHENTICATION_ERROR);
     }
     async requestResetPassword(email, redirectUrl) {
         const verifier = base64URLEncode(crypto__namespace.randomBytes(32));
@@ -4713,25 +4802,23 @@ class AuthManager {
         await this.backendApiClients.authenticationApi.requestResetPassword(request);
     }
     async resetPassword(email, password, state) {
-        const pkceData = this.deviceCredentialsManager.getPKCEData();
-        if (!pkceData) {
-            throw new Error('No code verifier or state for PKCE');
-        }
-        if (state !== pkceData.state) {
-            throw new Error('Provided state does not match stored state');
-        }
-        const request = {
-            resetPasswordRequest: {
-                email,
-                password,
-                state,
-                challenge: {
-                    codeVerifier: pkceData.verifier,
-                    method: CodeChallengeMethodEnum.S256,
+        return withOpenfortError(async () => {
+            const pkceData = this.deviceCredentialsManager.getPKCEData();
+            if (!pkceData) {
+                throw new Error('No code verifier or state for PKCE');
+            }
+            const request = {
+                resetPasswordRequest: {
+                    email,
+                    password,
+                    state,
+                    challenge: {
+                        codeVerifier: pkceData.verifier,
+                    },
                 },
-            },
-        };
-        await this.backendApiClients.authenticationApi.resetPassword(request);
+            };
+            await this.backendApiClients.authenticationApi.resetPassword(request);
+        }, OpenfortErrorType.AUTHENTICATION_ERROR);
     }
     async requestEmailVerification(email, redirectUrl) {
         const verifier = base64URLEncode(crypto__namespace.randomBytes(32));
@@ -4752,24 +4839,22 @@ class AuthManager {
         await this.backendApiClients.authenticationApi.requestEmailVerification(request);
     }
     async verifyEmail(email, state) {
-        const pkceData = this.deviceCredentialsManager.getPKCEData();
-        if (!pkceData) {
-            throw new Error('No code verifier or state for PKCE');
-        }
-        if (state !== pkceData.state) {
-            throw new Error('Provided state does not match stored state');
-        }
-        const request = {
-            verifyEmailRequest: {
-                email,
-                token: state,
-                challenge: {
-                    codeVerifier: pkceData.verifier,
-                    method: CodeChallengeMethodEnum.S256,
+        return withOpenfortError(async () => {
+            const pkceData = this.deviceCredentialsManager.getPKCEData();
+            if (!pkceData) {
+                throw new Error('No code verifier or state for PKCE');
+            }
+            const request = {
+                verifyEmailRequest: {
+                    email,
+                    token: state,
+                    challenge: {
+                        codeVerifier: pkceData.verifier,
+                    },
                 },
-            },
-        };
-        await this.backendApiClients.authenticationApi.verifyEmail(request);
+            };
+            await this.backendApiClients.authenticationApi.verifyEmail(request);
+        }, OpenfortErrorType.AUTHENTICATION_ERROR);
     }
     async signupEmailPassword(email, password, name) {
         const request = {
@@ -4779,8 +4864,10 @@ class AuthManager {
                 name,
             },
         };
-        const response = await this.backendApiClients.authenticationApi.signupEmailPassword(request);
-        return response.data;
+        return withOpenfortError(async () => {
+            const response = await this.backendApiClients.authenticationApi.signupEmailPassword(request);
+            return response.data;
+        }, OpenfortErrorType.USER_REGISTRATION_ERROR);
     }
     async validateCredentials(accessToken, refreshToken, jwk) {
         try {
@@ -4804,12 +4891,14 @@ class AuthManager {
                         refreshToken,
                     },
                 };
-                const newToken = await this.backendApiClients.authenticationApi.refresh(request);
-                return {
-                    player: newToken.data.player.id,
-                    accessToken: newToken.data.token,
-                    refreshToken: newToken.data.refreshToken,
-                };
+                return withOpenfortError(async () => {
+                    const newToken = await this.backendApiClients.authenticationApi.refresh(request);
+                    return {
+                        player: newToken.data.player.id,
+                        accessToken: newToken.data.token,
+                        refreshToken: newToken.data.refreshToken,
+                    };
+                }, OpenfortErrorType.REFRESH_TOKEN_ERROR);
             }
             throw error;
         }
@@ -4820,57 +4909,172 @@ class AuthManager {
                 refreshToken,
             },
         };
-        await this.backendApiClients.authenticationApi.logout(request, {
+        withOpenfortError(async () => {
+            await this.backendApiClients.authenticationApi.logout(request, {
+                headers: {
+                    authorization: `Bearer ${this.config.baseConfiguration.publishableKey}`,
+                    // eslint-disable-next-line @typescript-eslint/naming-convention
+                    'x-player-token': accessToken,
+                },
+            });
+        }, OpenfortErrorType.LOGOUT_ERROR);
+    }
+    async getUser(accessToken) {
+        // TODO: Add storage of user info
+        const response = await this.backendApiClients.authenticationApi.me({
             headers: {
                 authorization: `Bearer ${this.config.baseConfiguration.publishableKey}`,
                 // eslint-disable-next-line @typescript-eslint/naming-convention
                 'x-player-token': accessToken,
             },
         });
+        return response.data;
+    }
+    async linkOAuth(provider, playerToken, options) {
+        const request = {
+            oAuthInitRequest: {
+                provider,
+                options,
+                usePooling: options?.usePooling || false,
+            },
+        };
+        const result = await this.backendApiClients.authenticationApi.linkOAuth(request, {
+            headers: {
+                authorization: `Bearer ${this.config.baseConfiguration.publishableKey}`,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-player-token': playerToken,
+            },
+        });
+        if (isBrowser() && !options?.skipBrowserRedirect) {
+            window.location.assign(result.data.url);
+        }
+        return {
+            url: result.data.url,
+            key: result.data.key,
+        };
+    }
+    async unlinkOAuth(provider, accessToken) {
+        const request = {
+            unlinkOAuthRequest: {
+                provider,
+            },
+        };
+        const authPlayerResponse = await this.backendApiClients.authenticationApi.unlinkOAuth(request, {
+            headers: {
+                authorization: `Bearer ${this.config.baseConfiguration.publishableKey}`,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-player-token': accessToken,
+            },
+        });
+        return authPlayerResponse.data;
+    }
+    async unlinkWallet(address, accessToken) {
+        const request = {
+            sIWERequest: {
+                address,
+            },
+        };
+        const authPlayerResponse = await this.backendApiClients.authenticationApi.unlinkSIWE(request, {
+            headers: {
+                authorization: `Bearer ${this.config.baseConfiguration.publishableKey}`,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-player-token': accessToken,
+            },
+        });
+        return authPlayerResponse.data;
+    }
+    async linkWallet(signature, message, walletClientType, connectorType, accessToken) {
+        const request = {
+            sIWEAuthenticateRequest: {
+                signature,
+                message,
+                walletClientType,
+                connectorType,
+            },
+        };
+        const authPlayerResponse = await this.backendApiClients.authenticationApi.linkSIWE(request, {
+            headers: {
+                authorization: `Bearer ${this.config.baseConfiguration.publishableKey}`,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-player-token': accessToken,
+            },
+        });
+        return authPlayerResponse.data;
+    }
+    async unlinkEmail(email, accessToken) {
+        const request = {
+            unlinkEmailRequest: {
+                email,
+            },
+        };
+        const authPlayerResponse = await this.backendApiClients.authenticationApi.unlinkEmail(request, {
+            headers: {
+                authorization: `Bearer ${this.config.baseConfiguration.publishableKey}`,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-player-token': accessToken,
+            },
+        });
+        return authPlayerResponse.data;
+    }
+    async linkEmail(email, password, accessToken) {
+        const request = {
+            loginRequest: {
+                email,
+                password,
+            },
+        };
+        const authPlayerResponse = await this.backendApiClients.authenticationApi.linkEmail(request, {
+            headers: {
+                authorization: `Bearer ${this.config.baseConfiguration.publishableKey}`,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-player-token': accessToken,
+            },
+        });
+        return authPlayerResponse.data;
+    }
+}
+
+const authTokenStorageKey = 'openfort.auth_token';
+const thirdPartyProviderStorageKey = 'openfort.third_party_provider';
+const thirdPartyProviderTokenTypeStorageKey = 'openfort.third_party_provider_token_type';
+const refreshTokenStorageKey = 'openfort.refresh_token';
+const playerIDStorageKey = 'openfort.player_id';
+const sessionKeyStorageKey = 'openfort.session_key';
+const signerTypeStorageKey = 'openfort.signer_type';
+const chainIDStorageKey = 'openfort.chain_id';
+const jwksStorageKey = 'openfort.jwk';
+const deviceIDStorageKey = 'openfort.device_id';
+const accountTypeStorageKey = 'openfort.account_type';
+const accountAddressStorageKey = 'openfort.account_address';
+
+class InstanceManager {
+    authToken = null;
+    refreshToken = null;
+    signerType = null;
+    jwk = null;
+    sessionKey = null;
+    deviceID = null;
+    chainId = null;
+    accountAddress = null;
+    accountType = null;
+    temporalStorage;
+    persistentStorage;
+    secureStorage;
+    config;
+    backendApiClients;
+    playerId = null;
+    constructor(temporalStorage, persistentStorage, secureStorage, config, backendApiClients) {
+        this.temporalStorage = temporalStorage;
+        this.persistentStorage = persistentStorage;
+        this.secureStorage = secureStorage;
+        this.config = config;
+        this.backendApiClients = backendApiClients;
     }
-}
-
-const authTokenStorageKey = 'openfort.auth_token';
-const thirdPartyProviderStorageKey = 'openfort.third_party_provider';
-const thirdPartyProviderTokenTypeStorageKey = 'openfort.third_party_provider_token_type';
-const refreshTokenStorageKey = 'openfort.refresh_token';
-const playerIDStorageKey = 'openfort.player_id';
-const sessionKeyStorageKey = 'openfort.session_key';
-const signerTypeStorageKey = 'openfort.signer_type';
-const chainIDStorageKey = 'openfort.chain_id';
-const jwksStorageKey = 'openfort.jwk';
-const deviceIDStorageKey = 'openfort.device_id';
-const accountTypeStorageKey = 'openfort.account_type';
-const accountAddressStorageKey = 'openfort.account_address';
-
-class InstanceManager {
-    authToken = null;
-    refreshToken = null;
-    signerType = null;
-    jwk = null;
-    sessionKey = null;
-    deviceID = null;
-    chainId = null;
-    accountAddress = null;
-    accountType = null;
-    temporalStorage;
-    persistentStorage;
-    secureStorage;
-    config;
-    backendApiClients;
-    playerId = null;
-    constructor(temporalStorage, persistentStorage, secureStorage, config, backendApiClients) {
-        this.temporalStorage = temporalStorage;
-        this.persistentStorage = persistentStorage;
-        this.secureStorage = secureStorage;
-        this.config = config;
-        this.backendApiClients = backendApiClients;
-    }
     getAccessToken() {
         if (!this.authToken) {
             const token = this.secureStorage.get(authTokenStorageKey);
             if (token === null)
-                return null; // Early exit if no token is found
+                return null;
             this.authToken = {
                 token,
                 thirdPartyProvider: this.secureStorage.get(thirdPartyProviderStorageKey),
@@ -5652,34 +5856,6 @@ class IframeManager {
     }
 }
 
-class NotLoggedIn extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'NotLoggedIn';
-        Object.setPrototypeOf(this, NotLoggedIn.prototype);
-    }
-}
-class EmbeddedNotConfigured extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'EmbeddedNotConfigured';
-        Object.setPrototypeOf(this, EmbeddedNotConfigured.prototype);
-    }
-}
-class NoSignerConfigured extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'NoSignerConfigured';
-        Object.setPrototypeOf(this, NoSignerConfigured.prototype);
-    }
-}
-class NothingToSign extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'NothingToSign';
-        Object.setPrototypeOf(this, NothingToSign.prototype);
-    }
-}
 class Openfort {
     signer;
     authManager;
@@ -5696,6 +5872,9 @@ class Openfort {
         this.openfortEventEmitter = new TypedEventEmitter();
         this.iframeManager = new IframeManager(this.config);
     }
+    /**
+     * Logs the user out by flushing the signer and removing credentials.
+     */
     async logout() {
         await this.flushSigner();
         if (this.credentialsProvided()) {
@@ -5725,11 +5904,16 @@ class Openfort {
             this.instanceManager.removeJWK();
         }
     }
-    getEthereumProvider(options = {
-        announceProvider: true,
-    }) {
+    /**
+     * Returns an Ethereum provider using the configured signer.
+     *
+     * @param options - Configuration options for the Ethereum provider.
+     * @returns A Provider instance.
+     * @throws {OpenfortError} If the signer is not an EmbeddedSigner.
+     */
+    getEthereumProvider(options = { announceProvider: true }) {
         if (!(this.signer instanceof EmbeddedSigner)) {
-            throw new EmbeddedNotConfigured('Embedded signer must be configured to get Ethereum provider');
+            throw new OpenfortError('Embedded signer must be configured to get Ethereum provider', OpenfortErrorType.NOT_LOGGED_IN_ERROR);
         }
         const address = this.instanceManager.getAccountAddress();
         const provider = new EvmProvider({
@@ -5748,32 +5932,11 @@ class Openfort {
         }
         return provider;
     }
-    async flushSigner() {
-        if (this.signer) {
-            await this.signer.logout();
-            this.instanceManager.removeSignerType();
-            return;
-        }
-        const signerType = this.instanceManager.getSignerType();
-        switch (signerType) {
-            case SignerType.EMBEDDED: {
-                const iframeConfiguration = {
-                    accessToken: this.instanceManager.getAccessToken()?.token ?? null,
-                    thirdPartyProvider: this.instanceManager.getAccessToken()?.thirdPartyProvider ?? null,
-                    thirdPartyTokenType: this.instanceManager.getAccessToken()?.thirdPartyTokenType ?? null,
-                    chainId: null,
-                    recovery: null,
-                };
-                const embeddedSigner = new EmbeddedSigner(this.iframeManager, this.instanceManager, iframeConfiguration);
-                await embeddedSigner.logout();
-                break;
-            }
-            case SignerType.SESSION:
-                this.configureSessionKey();
-                break;
-        }
-        this.instanceManager.removeSignerType();
-    }
+    /**
+     * Configures a session key and returns the session key details.
+     *
+     * @returns A SessionKey object containing the address and registration status.
+     */
     configureSessionKey() {
         const signer = new SessionSigner(this.instanceManager);
         this.signer = signer;
@@ -5785,6 +5948,13 @@ class Openfort {
         this.instanceManager.setSignerType(SignerType.SESSION);
         return { address: publicKey, isRegistered: true };
     }
+    /**
+     * Configures an embedded signer.
+     *
+     * @param chainId - The chain ID for the embedded signer.
+     * @param shieldAuthentication - Shield authentication details.
+     * @param recoveryPassword - Recovery password.
+     */
     async configureEmbeddedSigner(chainId, shieldAuthentication, recoveryPassword) {
         const signer = this.newEmbeddedSigner(chainId, shieldAuthentication);
         await this.validateAndRefreshToken();
@@ -5792,20 +5962,14 @@ class Openfort {
         this.signer = signer;
         this.instanceManager.setSignerType(SignerType.EMBEDDED);
     }
-    newEmbeddedSigner(chainId, shieldAuthentication) {
-        if (!this.credentialsProvided()) {
-            throw new NotLoggedIn('Must be logged in to configure embedded signer');
-        }
-        const iframeConfiguration = {
-            accessToken: this.instanceManager.getAccessToken()?.token ?? null,
-            thirdPartyProvider: this.instanceManager.getAccessToken()?.thirdPartyProvider ?? null,
-            thirdPartyTokenType: this.instanceManager.getAccessToken()?.thirdPartyTokenType ?? null,
-            chainId: chainId ?? null,
-            recovery: shieldAuthentication ?? null,
-        };
-        return new EmbeddedSigner(this.iframeManager, this.instanceManager, iframeConfiguration);
-    }
-    async loginWithEmailPassword(email, password) {
+    /**
+     * Logs in a user with email and password.
+     *
+     * @param email - User's email.
+     * @param password - User's password.
+     * @returns An AuthResponse object containing authentication details.
+     */
+    async loginWithEmailPassword({ email, password }) {
         this.instanceManager.removeAccessToken();
         this.instanceManager.removeRefreshToken();
         this.instanceManager.removePlayerID();
@@ -5817,11 +5981,19 @@ class Openfort {
         });
         return result;
     }
-    async signUpWithEmailPassword(email, password, name) {
+    /**
+     * Signs up a new user with email and password.
+     *
+     * @param email - User's email.
+     * @param password - User's password.
+     * @param options - Additional options for the sign-up process.
+     * @returns An AuthResponse object containing authentication details.
+     */
+    async signUpWithEmailPassword({ email, password, options }) {
         this.instanceManager.removeAccessToken();
         this.instanceManager.removeRefreshToken();
         this.instanceManager.removePlayerID();
-        const result = await this.authManager.signupEmailPassword(email, password, name);
+        const result = await this.authManager.signupEmailPassword(email, password, options?.data.name);
         this.storeCredentials({
             player: result.player.id,
             accessToken: result.token,
@@ -5829,45 +6001,117 @@ class Openfort {
         });
         return result;
     }
-    async requestEmailVerification(email, redirectUrl) {
+    /**
+     * Links an email and password to an existing account using an authentication token.
+     *
+     * @param email - User's email.
+     * @param password - User's password.
+     * @param authToken - Authentication token.
+     * @returns An AuthPlayerResponse object.
+     */
+    async linkEmailPassword({ email, password, authToken }) {
+        const result = await this.authManager.linkEmail(email, password, authToken);
+        return result;
+    }
+    /**
+     * Unlinks an email and password from an existing account using an authentication token.
+     *
+     * @param email - User's email.
+     * @param authToken - Authentication token.
+     * @returns An AuthPlayerResponse object.
+     */
+    async unlinkEmailPassword({ email, authToken }) {
+        const result = await this.authManager.unlinkEmail(email, authToken);
+        return result;
+    }
+    /**
+     * Requests an email verification link.
+     *
+     * @param email - User's email.
+     * @param redirectUrl - Redirect URL after verification.
+     */
+    async requestEmailVerification({ email, redirectUrl }) {
         await this.authManager.requestEmailVerification(email, redirectUrl);
     }
-    async resetPassword(email, password, state) {
+    /**
+     * Resets the user's password.
+     *
+     * @param email - User's email.
+     * @param password - New password.
+     * @param state - Verification state.
+     */
+    async resetPassword({ email, password, state }) {
         await this.authManager.resetPassword(email, password, state);
     }
-    async requestResetPassword(email, redirectUrl) {
+    /**
+     * Requests a password reset link.
+     *
+     * @param email - User's email.
+     * @param redirectUrl - Redirect URL after resetting password.
+     */
+    async requestResetPassword({ email, redirectUrl }) {
         await this.authManager.requestResetPassword(email, redirectUrl);
     }
-    async verifyEmail(email, state) {
+    /**
+     * Verifies the user's email.
+     *
+     * @param email - User's email.
+     * @param state - Verification state.
+     */
+    async verifyEmail({ email, state }) {
         await this.authManager.verifyEmail(email, state);
     }
-    async initOAuth(provider, usePooling, options) {
-        const authResponse = await this.authManager.initOAuth(provider, usePooling, options);
+    /**
+     * Initializes an OAuth authentication process.
+     *
+     * @param provider - OAuth provider.
+     * @param options - Additional options for initialization.
+     * @returns An InitAuthResponse object.
+     */
+    async initOAuth({ provider, options }) {
+        const authResponse = await this.authManager.initOAuth(provider, options);
         return authResponse;
     }
-    async initLinkOAuth(provider, playerToken, usePooling, options) {
-        return await this.authManager.initLinkOAuth(provider, playerToken, usePooling, options);
-    }
-    async poolOAuth(key) {
-        return await this.authManager.poolOAuth(key);
+    /**
+     * Initializes an OAuth linking process.
+     *
+     * @param provider - OAuth provider.
+     * @param authToken - Authentication token.
+     * @param options - Additional options for initialization.
+     * @returns An InitAuthResponse object.
+     */
+    async initLinkOAuth({ provider, authToken, options }) {
+        return await this.authManager.linkOAuth(provider, authToken, options);
     }
-    // @deprecated
-    async authenticateWithOAuth(provider, token, tokenType) {
-        this.instanceManager.removeAccessToken();
-        this.instanceManager.removeRefreshToken();
-        this.instanceManager.removePlayerID();
-        const result = await this.authManager.authenticateOAuth(provider, token, tokenType);
-        this.storeCredentials({
-            player: result.player.id,
-            accessToken: result.token,
-            refreshToken: result.refreshToken,
-        });
+    /**
+     * Unlinks an OAuth provider from the account.
+     *
+     * @param provider - OAuth provider.
+     * @param authToken - Authentication token.
+     * @returns An AuthPlayerResponse object.
+     */
+    async unlinkOAuth({ provider, authToken }) {
+        const result = await this.authManager.unlinkOAuth(provider, authToken);
         return result;
     }
-    async initSIWE(address) {
-        return await this.authManager.initSIWE(address);
+    /**
+     * Polls for OAuth authentication completion.
+     *
+     * @param key - OAuth polling key.
+     * @returns An AuthResponse object.
+     */
+    async poolOAuth(key) {
+        return await this.authManager.poolOAuth(key);
     }
-    async authenticateWithThirdPartyProvider(provider, token, tokenType) {
+    /**
+     * Authenticates using a third-party OAuth provider.
+     *
+     * @param provider - Third-party OAuth provider.
+     * @param token - OAuth token.
+     * @param tokenType - Type of the OAuth token.
+     * @returns An AuthPlayerResponse object.
+     */
+    async authenticateWithThirdPartyProvider({ provider, token, tokenType }) {
         const result = await this.authManager.authenticateThirdParty(provider, token, tokenType);
         this.instanceManager.setAccessToken({
             token,
@@ -5880,7 +6124,25 @@ class Openfort {
         }
         return result;
     }
-    async authenticateWithSIWE(signature, message, walletClientType, connectorType) {
+    /**
+     * Initializes Sign-In with Ethereum (SIWE).
+     *
+     * @param address - Ethereum address.
+     * @returns A SIWEInitResponse object.
+     */
+    async initSIWE({ address }) {
+        return await this.authManager.initSIWE(address);
+    }
+    /**
+     * Authenticates using Sign-In with Ethereum (SIWE).
+     *
+     * @param signature - SIWE signature.
+     * @param message - SIWE message.
+     * @param walletClientType - Wallet client type.
+     * @param connectorType - Connector type.
+     * @returns An AuthResponse object.
+     */
+    async authenticateWithSIWE({ signature, message, walletClientType, connectorType, }) {
         this.instanceManager.removeAccessToken();
         this.instanceManager.removeRefreshToken();
         this.instanceManager.removePlayerID();
@@ -5892,6 +6154,36 @@ class Openfort {
         });
         return result;
     }
+    /**
+     * Links a wallet using SIWE.
+     *
+     * @param signature - SIWE signature.
+     * @param message - SIWE message.
+     * @param walletClientType - Wallet client type.
+     * @param connectorType - Connector type.
+     * @param authToken - Authentication token.
+     * @returns An AuthPlayerResponse object.
+     */
+    async linkWallet({ signature, message, walletClientType, connectorType, authToken, }) {
+        const result = await this.authManager.linkWallet(signature, message, walletClientType, connectorType, authToken);
+        return result;
+    }
+    /**
+     * Unlinks a wallet.
+     *
+     * @param address - Wallet address.
+     * @param authToken - Authentication token.
+     * @returns An AuthPlayerResponse object.
+     */
+    async unlinkWallet({ address, authToken }) {
+        const result = await this.authManager.unlinkWallet(address, authToken);
+        return result;
+    }
+    /**
+     * Stores authentication credentials.
+     *
+     * @param auth - Authentication details.
+     */
     storeCredentials(auth) {
         this.instanceManager.setAccessToken({
             token: auth.accessToken,
@@ -5901,15 +6193,24 @@ class Openfort {
         this.instanceManager.setRefreshToken(auth.refreshToken);
         this.instanceManager.setPlayerID(auth.player);
     }
+    /**
+     * Sends a signature transaction intent request.
+     *
+     * @param transactionIntentId - Transaction intent ID.
+     * @param userOperationHash - User operation hash.
+     * @param signature - Transaction signature.
+     * @returns A TransactionIntentResponse object.
+     * @throws {OpenfortError} If no userOperationHash or signature is provided.
+     */
     async sendSignatureTransactionIntentRequest(transactionIntentId, userOperationHash = null, signature = null) {
         let newSignature = signature;
         if (!newSignature) {
             if (!userOperationHash) {
-                throw new NothingToSign('No userOperationHash or signature provided');
+                throw new OpenfortError('No userOperationHash or signature provided', OpenfortErrorType.OPERATION_NOT_SUPPORTED_ERROR);
             }
             await this.recoverSigner();
             if (!this.signer) {
-                throw new NoSignerConfigured('In order to sign a transaction intent, a signer must be configured');
+                throw new OpenfortError('In order to sign a transaction intent, a signer must be configured', OpenfortErrorType.MISSING_SIGNER_ERROR);
             }
             if (this.signer.useCredentials()) {
                 await this.validateAndRefreshToken();
@@ -5925,10 +6226,18 @@ class Openfort {
         const result = await this.backendApiClients.transactionIntentsApi.signature(request);
         return result.data;
     }
+    /**
+     * Signs a message.
+     *
+     * @param message - Message to sign.
+     * @param options - Additional options for signing.
+     * @returns The signature.
+     * @throws {OpenfortError} If no signer is configured.
+     */
     async signMessage(message, options) {
         await this.recoverSigner();
         if (!this.signer) {
-            throw new NoSignerConfigured('No signer configured');
+            throw new OpenfortError('In order to sign a message, an embedded signer must be configured', OpenfortErrorType.MISSING_EMBEDDED_SIGNER_ERROR);
         }
         if (this.signer.useCredentials()) {
             await this.validateAndRefreshToken();
@@ -5936,10 +6245,19 @@ class Openfort {
         const { hashMessage = true, arrayifyMessage = false } = options || {};
         return await this.signer.sign(message, arrayifyMessage, hashMessage);
     }
+    /**
+     * Signs typed data.
+     *
+     * @param domain - EIP-712 domain.
+     * @param types - Typed data types.
+     * @param value - Typed data value.
+     * @returns The signature.
+     * @throws {OpenfortError} If no signer is configured.
+     */
     async signTypedData(domain, types, value) {
         await this.recoverSigner();
         if (!this.signer) {
-            throw new NoSignerConfigured('No signer configured');
+            throw new OpenfortError('In order to sign a message, an embedded signer must be configured', OpenfortErrorType.MISSING_EMBEDDED_SIGNER_ERROR);
         }
         if (this.signer.useCredentials()) {
             await this.validateAndRefreshToken();
@@ -5969,13 +6287,23 @@ class Openfort {
         }
         return await this.signer.sign(hash$1, false, false);
     }
+    /**
+     * Sends a session registration request.
+     *
+     * @param sessionId - Session ID.
+     * @param signature - Session signature.
+     * @param optimistic - Whether the request is optimistic.
+     * @returns A SessionResponse object.
+     * @throws {OpenfortError} If no signer is configured.
+     * @throws {OpenfortError} If the signer is not a SessionSigner.
+     */
     async sendRegisterSessionRequest(sessionId, signature, optimistic) {
         await this.recoverSigner();
         if (!this.signer) {
-            throw new NoSignerConfigured('No signer configured nor signature provided');
+            throw new OpenfortError('No signer configured nor signature provided', OpenfortErrorType.MISSING_SIGNER_ERROR);
         }
         if (this.signer.getSingerType() !== SignerType.SESSION) {
-            throw new NoSignerConfigured('Session signer must be configured to sign a session');
+            throw new OpenfortError('Session signer must be configured to sign a session', OpenfortErrorType.MISSING_SESSION_SIGNER_ERROR);
         }
         const request = {
             id: sessionId,
@@ -5987,6 +6315,75 @@ class Openfort {
         const result = await this.backendApiClients.sessionsApi.signatureSession(request);
         return result.data;
     }
+    /**
+     * Gets the embedded state of the current session.
+     *
+     * @returns The embedded state.
+     */
+    getEmbeddedState() {
+        if (!this.credentialsProvided()) {
+            return exports.EmbeddedState.UNAUTHENTICATED;
+        }
+        if (this.instanceManager.getSignerType() !== SignerType.EMBEDDED) {
+            return exports.EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED;
+        }
+        if (!this.signer) {
+            this.signer = this.newEmbeddedSigner();
+        }
+        if (!this.instanceManager.getDeviceID()) {
+            return exports.EmbeddedState.CREATING_ACCOUNT;
+        }
+        return exports.EmbeddedState.READY;
+    }
+    /**
+     * Gets the current access token.
+     *
+     * @returns The access token, or null if not available.
+     */
+    getAccessToken() {
+        return this.instanceManager.getAccessToken()?.token ?? null;
+    }
+    /**
+     * Retrieves the user details.
+     *
+     * @returns An AuthPlayerResponse object.
+     * @throws {OpenfortError} If no access token is found.
+     */
+    async getUser() {
+        await this.validateAndRefreshToken();
+        const accessToken = this.instanceManager.getAccessToken();
+        if (!accessToken) {
+            throw new OpenfortError('No accessToken found', OpenfortErrorType.NOT_LOGGED_IN_ERROR);
+        }
+        return await this.authManager.getUser(accessToken.token);
+    }
+    /**
+     * Validates and refreshes the access token if needed.
+     */
+    async validateAndRefreshToken() {
+        if (!this.credentialsProvided()) {
+            return;
+        }
+        const accessToken = this.instanceManager.getAccessToken();
+        const refreshToken = this.instanceManager.getRefreshToken();
+        const jwk = await this.instanceManager.getJWK();
+        if (!accessToken || !refreshToken || !jwk) {
+            return;
+        }
+        const auth = await this.authManager.validateCredentials(accessToken.token, refreshToken, jwk);
+        if (auth.accessToken !== accessToken.token) {
+            this.storeCredentials(auth);
+        }
+        if (this.signer && this.signer.useCredentials()) {
+            await this.signer.updateAuthentication();
+        }
+    }
+    credentialsProvided() {
+        const token = this.instanceManager.getAccessToken();
+        const refreshToken = this.instanceManager.getRefreshToken();
+        return token && ((token.token && token.thirdPartyProvider && token.thirdPartyTokenType)
+            || (token.token && refreshToken));
+    }
     async recoverSigner() {
         if (this.signer) {
             return;
@@ -6020,78 +6417,49 @@ class Openfort {
         };
         await checkSignerType(0);
     }
-    getEmbeddedState() {
-        if (!this.credentialsProvided()) {
-            return exports.EmbeddedState.UNAUTHENTICATED;
-        }
-        if (this.instanceManager.getSignerType() !== SignerType.EMBEDDED) {
-            return exports.EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED;
-        }
-        if (!this.signer) {
-            this.signer = this.newEmbeddedSigner();
-        }
-        if (!this.instanceManager.getDeviceID()) {
-            return exports.EmbeddedState.CREATING_ACCOUNT;
-        }
-        return exports.EmbeddedState.READY;
-    }
-    credentialsProvided() {
-        const token = this.instanceManager.getAccessToken();
-        const refreshToken = this.instanceManager.getRefreshToken();
-        return (token
-            && ((token.token && token.thirdPartyProvider && token.thirdPartyTokenType)
-                || (token.token && refreshToken)));
-    }
-    async isAuthenticated() {
+    newEmbeddedSigner(chainId, shieldAuthentication) {
         if (!this.credentialsProvided()) {
-            return false;
+            throw new OpenfortError('Must be logged in to configure embedded signer', OpenfortErrorType.NOT_LOGGED_IN_ERROR);
         }
-        if (!this.signer) {
-            const signerType = this.instanceManager.getSignerType();
-            if (signerType !== SignerType.EMBEDDED) {
-                return false;
-            }
-            const signer = this.newEmbeddedSigner();
-            return await signer.isLoaded();
-        }
-        if (this.signer.getSingerType() !== SignerType.EMBEDDED) {
-            return false;
-        }
-        return await this.signer.isLoaded();
-    }
-    getAccessToken() {
-        return this.instanceManager.getAccessToken()?.token ?? null;
-    }
-    isLoaded() {
-        if (!this.instanceManager.getJWK()) {
-            return false;
-        }
-        if (this.signer && this.signer.getSingerType() === SignerType.EMBEDDED) {
-            return this.signer.iFrameLoaded();
-        }
-        return true;
+        const iframeConfiguration = {
+            accessToken: this.instanceManager.getAccessToken()?.token ?? null,
+            thirdPartyProvider: this.instanceManager.getAccessToken()?.thirdPartyProvider ?? null,
+            thirdPartyTokenType: this.instanceManager.getAccessToken()?.thirdPartyTokenType ?? null,
+            chainId: !chainId ? Number(this.instanceManager.getChainID()) ?? null : chainId,
+            recovery: shieldAuthentication ?? null,
+        };
+        return new EmbeddedSigner(this.iframeManager, this.instanceManager, iframeConfiguration);
     }
-    async validateAndRefreshToken() {
-        if (!this.credentialsProvided()) {
-            return;
-        }
-        const accessToken = this.instanceManager.getAccessToken();
-        const refreshToken = this.instanceManager.getRefreshToken();
-        const jwk = await this.instanceManager.getJWK();
-        if (!accessToken || !refreshToken || !jwk) {
+    async flushSigner() {
+        if (this.signer) {
+            await this.signer.logout();
+            this.instanceManager.removeSignerType();
             return;
         }
-        const auth = await this.authManager.validateCredentials(accessToken.token, refreshToken, jwk);
-        if (auth.accessToken !== accessToken.token) {
-            this.storeCredentials(auth);
-        }
-        if (this.signer && this.signer.useCredentials()) {
-            await this.signer.updateAuthentication();
+        const signerType = this.instanceManager.getSignerType();
+        switch (signerType) {
+            case SignerType.EMBEDDED: {
+                const iframeConfiguration = {
+                    accessToken: this.instanceManager.getAccessToken()?.token ?? null,
+                    thirdPartyProvider: this.instanceManager.getAccessToken()?.thirdPartyProvider ?? null,
+                    thirdPartyTokenType: this.instanceManager.getAccessToken()?.thirdPartyTokenType ?? null,
+                    chainId: null,
+                    recovery: null,
+                };
+                const embeddedSigner = new EmbeddedSigner(this.iframeManager, this.instanceManager, iframeConfiguration);
+                await embeddedSigner.logout();
+                break;
+            }
+            case SignerType.SESSION:
+                this.configureSessionKey();
+                break;
         }
+        this.instanceManager.removeSignerType();
     }
 }
 
 exports.OpenfortConfiguration = OpenfortConfiguration;
+exports.OpenfortError = OpenfortError;
 exports.SDKConfiguration = SDKConfiguration;
 exports.ShieldConfiguration = ShieldConfiguration;
 exports.default = Openfort;