@openfort/openfort-js 0.7.6 → 0.7.7

package/dist/index.js

@@ -1,5 +1,5 @@
 import { _TypedDataEncoder, hashMessage } from '@ethersproject/hash';
-import globalAxios from 'axios';
+import globalAxios, { isAxiosError } from 'axios';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { hexlify, joinSignature, arrayify } from '@ethersproject/bytes';
 import { EventEmitter } from 'events';
@@ -1011,15 +1011,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;
@@ -1029,6 +1029,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 : {};
@@ -1040,16 +1043,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;
@@ -1066,23 +1069,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;
@@ -1092,14 +1094,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,
@@ -1296,7 +1325,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;
@@ -1329,7 +1358,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;
@@ -1362,7 +1391,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;
@@ -1451,16 +1480,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);
@@ -1475,7 +1533,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,
@@ -1521,7 +1579,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;
@@ -1670,17 +1728,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.
@@ -1703,6 +1750,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.
@@ -1822,15 +1890,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);
         },
         /**
@@ -1933,17 +2011,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.
@@ -1966,6 +2033,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.
@@ -2085,6 +2173,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
@@ -2094,7 +2192,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));
     }
     /**
      *
@@ -2973,16 +3071,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) {
@@ -2990,6 +3090,21 @@ class OpenfortError extends Error {
         this.type = type;
     }
 }
+const withOpenfortError = async (fn, customErrorType) => {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        let errorMessage;
+        if (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
@@ -4544,12 +4659,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);
@@ -4561,26 +4676,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,
@@ -4613,18 +4708,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: {
@@ -4633,8 +4716,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 = {
@@ -4658,8 +4743,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 = {
@@ -4668,8 +4755,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.randomBytes(32));
@@ -4690,25 +4779,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.randomBytes(32));
@@ -4729,24 +4816,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 = {
@@ -4756,8 +4841,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 {
@@ -4781,12 +4868,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;
         }
@@ -4797,13 +4886,128 @@ 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;
     }
 }
 
@@ -4847,7 +5051,7 @@ class InstanceManager {
         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),
@@ -5629,34 +5833,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;
@@ -5706,7 +5882,7 @@ class Openfort {
         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({
@@ -5771,18 +5947,18 @@ class Openfort {
     }
     newEmbeddedSigner(chainId, shieldAuthentication) {
         if (!this.credentialsProvided()) {
-            throw new NotLoggedIn('Must be logged in to configure embedded signer');
+            throw new OpenfortError('Must be logged in to configure embedded signer', OpenfortErrorType.NOT_LOGGED_IN_ERROR);
         }
         const iframeConfiguration = {
             accessToken: this.instanceManager.getAccessToken()?.token ?? null,
             thirdPartyProvider: this.instanceManager.getAccessToken()?.thirdPartyProvider ?? null,
             thirdPartyTokenType: this.instanceManager.getAccessToken()?.thirdPartyTokenType ?? null,
-            chainId: chainId ?? null,
+            chainId: !chainId ? Number(this.instanceManager.getChainID()) ?? null : chainId,
             recovery: shieldAuthentication ?? null,
         };
         return new EmbeddedSigner(this.iframeManager, this.instanceManager, iframeConfiguration);
     }
-    async loginWithEmailPassword(email, password) {
+    async loginWithEmailPassword({ email, password, }) {
         this.instanceManager.removeAccessToken();
         this.instanceManager.removeRefreshToken();
         this.instanceManager.removePlayerID();
@@ -5794,11 +5970,11 @@ class Openfort {
         });
         return result;
     }
-    async signUpWithEmailPassword(email, password, name) {
+    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,
@@ -5806,45 +5982,32 @@ class Openfort {
         });
         return result;
     }
-    async requestEmailVerification(email, redirectUrl) {
+    async requestEmailVerification({ email, redirectUrl }) {
         await this.authManager.requestEmailVerification(email, redirectUrl);
     }
-    async resetPassword(email, password, state) {
+    async resetPassword({ email, password, state }) {
         await this.authManager.resetPassword(email, password, state);
     }
-    async requestResetPassword(email, redirectUrl) {
+    async requestResetPassword({ email, redirectUrl }) {
         await this.authManager.requestResetPassword(email, redirectUrl);
     }
-    async verifyEmail(email, 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);
+    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 initLinkOAuth({ provider, playerToken, options }) {
+        return await this.authManager.linkOAuth(provider, playerToken, options);
     }
     async poolOAuth(key) {
         return await this.authManager.poolOAuth(key);
     }
-    // @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,
-        });
-        return result;
-    }
-    async initSIWE(address) {
+    async initSIWE({ address }) {
         return await this.authManager.initSIWE(address);
     }
-    async authenticateWithThirdPartyProvider(provider, token, tokenType) {
+    async authenticateWithThirdPartyProvider({ provider, token, tokenType }) {
         const result = await this.authManager.authenticateThirdParty(provider, token, tokenType);
         this.instanceManager.setAccessToken({
             token,
@@ -5857,7 +6020,7 @@ class Openfort {
         }
         return result;
     }
-    async authenticateWithSIWE(signature, message, walletClientType, connectorType) {
+    async authenticateWithSIWE({ signature, message, walletClientType, connectorType, }) {
         this.instanceManager.removeAccessToken();
         this.instanceManager.removeRefreshToken();
         this.instanceManager.removePlayerID();
@@ -5882,11 +6045,11 @@ class Openfort {
         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();
@@ -5905,7 +6068,7 @@ class Openfort {
     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();
@@ -5916,7 +6079,7 @@ class Openfort {
     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();
@@ -5949,10 +6112,10 @@ class Openfort {
     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,
@@ -6019,23 +6182,6 @@ class Openfort {
             && ((token.token && token.thirdPartyProvider && token.thirdPartyTokenType)
                 || (token.token && refreshToken)));
     }
-    async isAuthenticated() {
-        if (!this.credentialsProvided()) {
-            return false;
-        }
-        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;
     }
@@ -6048,6 +6194,14 @@ class Openfort {
         }
         return true;
     }
+    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);
+    }
     async validateAndRefreshToken() {
         if (!this.credentialsProvided()) {
             return;