@openfort/openfort-js 0.7.14 → 0.7.16

package/dist/index.cjs

@@ -3195,57 +3195,6 @@ var CodeChallengeMethodEnum;
     CodeChallengeMethodEnum["S256"] = "S256";
 })(CodeChallengeMethodEnum || (CodeChallengeMethodEnum = {}));
 
-var OpenfortErrorType;
-(function (OpenfortErrorType) {
-    OpenfortErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
-    OpenfortErrorType["INVALID_CONFIGURATION"] = "INVALID_CONFIGURATION";
-    OpenfortErrorType["NOT_LOGGED_IN_ERROR"] = "NOT_LOGGED_IN_ERROR";
-    OpenfortErrorType["REFRESH_TOKEN_ERROR"] = "REFRESH_TOKEN_ERROR";
-    OpenfortErrorType["USER_REGISTRATION_ERROR"] = "USER_REGISTRATION_ERROR";
-    OpenfortErrorType["LOGOUT_ERROR"] = "LOGOUT_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 'type' in error && 'message' in error;
-}
-class OpenfortError extends Error {
-    type;
-    constructor(message, type) {
-        super(message);
-        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
-        .map((key) => !configuration[key] && key)
-        .filter((n) => n)
-        .join(', ');
-    if (missingKeys !== '') {
-        const errorMessage = prefix
-            ? `${prefix} - ${missingKeys} cannot be null`
-            : `${missingKeys} cannot be null`;
-        throw new OpenfortError(errorMessage, OpenfortErrorType.INVALID_CONFIGURATION);
-    }
-};
 class OpenfortConfiguration {
     publishableKey;
     constructor(options) {
@@ -3273,17 +3222,12 @@ class SDKConfiguration {
         this.shieldConfiguration = shieldConfiguration;
         this.baseConfiguration = baseConfiguration;
         if (overrides) {
-            validateConfiguration(overrides, [
-                'backendUrl',
-                'iframeUrl',
-                'shieldUrl',
-            ], 'overrides');
-            this.backendUrl = overrides.backendUrl;
-            this.iframeUrl = overrides.iframeUrl;
-            this.shieldUrl = overrides.shieldUrl;
+            this.backendUrl = overrides.backendUrl || 'https://api.openfort.xyz';
+            this.iframeUrl = overrides.iframeUrl || 'https://iframe.openfort.xyz';
+            this.shieldUrl = overrides.shieldUrl || 'https://shield.openfort.xyz';
             this.openfortAPIConfig = {
                 backend: createConfig({
-                    basePath: overrides.backendUrl,
+                    basePath: overrides.backendUrl || 'https://api.openfort.xyz',
                     accessToken: baseConfiguration.publishableKey,
                 }),
             };
@@ -4742,6 +4686,69 @@ function announceProvider(detail) {
     window.addEventListener('eip6963:requestProvider', handler);
 }
 
+exports.OpenfortErrorType = void 0;
+(function (OpenfortErrorType) {
+    OpenfortErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
+    OpenfortErrorType["INVALID_CONFIGURATION"] = "INVALID_CONFIGURATION";
+    OpenfortErrorType["NOT_LOGGED_IN_ERROR"] = "NOT_LOGGED_IN_ERROR";
+    OpenfortErrorType["REFRESH_TOKEN_ERROR"] = "REFRESH_TOKEN_ERROR";
+    OpenfortErrorType["USER_REGISTRATION_ERROR"] = "USER_REGISTRATION_ERROR";
+    OpenfortErrorType["LOGOUT_ERROR"] = "LOGOUT_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["USER_NOT_AUTHORIZED_ON_ECOSYSTEM"] = "USER_NOT_AUTHORIZED_ON_ECOSYSTEM";
+})(exports.OpenfortErrorType || (exports.OpenfortErrorType = {}));
+function isAPIError(error) {
+    return 'type' in error && 'message' in error;
+}
+class OpenfortError extends Error {
+    type;
+    data;
+    constructor(message, type, data = {}) {
+        super(message);
+        this.type = type;
+        this.data = data;
+    }
+}
+const withOpenfortError = async (fn, customErrorType) => {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        let errorMessage;
+        const data = {};
+        let errorType = customErrorType.default;
+        if (globalAxios.isAxiosError(error)) {
+            const statusCode = error.response?.status;
+            errorType = statusCode ? customErrorType[statusCode] || customErrorType.default : customErrorType.default;
+            if (error.response?.data && error.response.data.error) {
+                const jsonData = JSON.parse(JSON.stringify(error.response.data.error));
+                // eslint-disable-next-line no-restricted-syntax
+                for (const key in jsonData) {
+                    if (key !== 'message' && key !== 'type') {
+                        data[key] = jsonData[key];
+                    }
+                }
+                if (isAPIError(error.response.data)) {
+                    errorMessage = error.response.data.message;
+                }
+                else {
+                    errorMessage = error.message;
+                }
+            }
+            else {
+                errorMessage = error.message;
+            }
+        }
+        else {
+            errorMessage = error.message;
+        }
+        throw new OpenfortError(errorMessage, errorType, data);
+    }
+};
+
 var SignerType;
 (function (SignerType) {
     SignerType["EMBEDDED"] = "embedded";
@@ -4787,7 +4794,7 @@ class AuthManager {
         this.backendApiClients = backendApiClients;
         this.instanceManager = instanceManager;
     }
-    async initOAuth(provider, options) {
+    async initOAuth(provider, options, ecosystemGame) {
         const usePooling = options?.usePooling ?? false;
         // eslint-disable-next-line no-param-reassign
         delete options?.usePooling;
@@ -4798,7 +4805,7 @@ class AuthManager {
                 usePooling,
             },
         };
-        const result = await this.backendApiClients.authenticationApi.initOAuth(request);
+        const result = await this.backendApiClients.authenticationApi.initOAuth(request, AuthManager.getEcosystemGameOptsOrUndefined(ecosystemGame));
         if (isBrowser() && options?.skipBrowserRedirect) {
             window.location.assign(result.data.url);
         }
@@ -4839,7 +4846,7 @@ class AuthManager {
         }
         throw new Error('Failed to pool OAuth, try again later');
     }
-    async authenticateThirdParty(provider, token, tokenType) {
+    async authenticateThirdParty(provider, token, tokenType, ecosystemGame) {
         const request = {
             thirdPartyOAuthRequest: {
                 provider,
@@ -4848,17 +4855,17 @@ class AuthManager {
             },
         };
         return withOpenfortError(async () => {
-            const response = await this.backendApiClients.authenticationApi.thirdParty(request);
+            const response = await this.backendApiClients.authenticationApi.thirdParty(request, AuthManager.getEcosystemGameOptsOrUndefined(ecosystemGame));
             return response.data;
-        }, OpenfortErrorType.AUTHENTICATION_ERROR);
+        }, { default: exports.OpenfortErrorType.AUTHENTICATION_ERROR });
     }
-    async initSIWE(address) {
+    async initSIWE(address, ecosystemGame) {
         const request = {
             sIWERequest: {
                 address,
             },
         };
-        const result = await this.backendApiClients.authenticationApi.initSIWE(request);
+        const result = await this.backendApiClients.authenticationApi.initSIWE(request, AuthManager.getEcosystemGameOptsOrUndefined(ecosystemGame));
         return {
             address: result.data.address,
             nonce: result.data.nonce,
@@ -4877,9 +4884,20 @@ class AuthManager {
         return withOpenfortError(async () => {
             const response = await this.backendApiClients.authenticationApi.authenticateSIWE(request);
             return response.data;
-        }, OpenfortErrorType.AUTHENTICATION_ERROR);
+        }, { default: exports.OpenfortErrorType.AUTHENTICATION_ERROR });
+    }
+    static getEcosystemGameOptsOrUndefined(ecosystemGame) {
+        if (ecosystemGame) {
+            return {
+                headers: {
+                    // eslint-disable-next-line @typescript-eslint/naming-convention
+                    'x-game': ecosystemGame,
+                },
+            };
+        }
+        return undefined;
     }
-    async loginEmailPassword(email, password) {
+    async loginEmailPassword(email, password, ecosystemGame) {
         const request = {
             loginRequest: {
                 email,
@@ -4887,9 +4905,10 @@ class AuthManager {
             },
         };
         return withOpenfortError(async () => {
-            const response = await this.backendApiClients.authenticationApi.loginEmailPassword(request);
+            const response = await this.backendApiClients.authenticationApi.loginEmailPassword(request, AuthManager.getEcosystemGameOptsOrUndefined(ecosystemGame));
             return response.data;
-        }, OpenfortErrorType.AUTHENTICATION_ERROR);
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+        }, { default: exports.OpenfortErrorType.AUTHENTICATION_ERROR, 403: exports.OpenfortErrorType.USER_NOT_AUTHORIZED_ON_ECOSYSTEM });
     }
     async requestResetPassword(email, redirectUrl) {
         const verifier = base64URLEncode(crypto__namespace.randomBytes(32));
@@ -4926,7 +4945,7 @@ class AuthManager {
                 },
             };
             await this.backendApiClients.authenticationApi.resetPassword(request);
-        }, OpenfortErrorType.AUTHENTICATION_ERROR);
+        }, { default: exports.OpenfortErrorType.AUTHENTICATION_ERROR });
     }
     async requestEmailVerification(email, redirectUrl) {
         const verifier = base64URLEncode(crypto__namespace.randomBytes(32));
@@ -4962,9 +4981,9 @@ class AuthManager {
                 },
             };
             await this.backendApiClients.authenticationApi.verifyEmail(request);
-        }, OpenfortErrorType.AUTHENTICATION_ERROR);
+        }, { default: exports.OpenfortErrorType.AUTHENTICATION_ERROR });
     }
-    async signupEmailPassword(email, password, name) {
+    async signupEmailPassword(email, password, name, ecosystemGame) {
         const request = {
             signupRequest: {
                 email,
@@ -4973,16 +4992,16 @@ class AuthManager {
             },
         };
         return withOpenfortError(async () => {
-            const response = await this.backendApiClients.authenticationApi.signupEmailPassword(request);
+            const response = await this.backendApiClients.authenticationApi.signupEmailPassword(request, AuthManager.getEcosystemGameOptsOrUndefined(ecosystemGame));
             return response.data;
-        }, OpenfortErrorType.USER_REGISTRATION_ERROR);
+        }, { default: exports.OpenfortErrorType.USER_REGISTRATION_ERROR });
     }
     async validateCredentials(forceRefresh) {
         const jwk = await this.instanceManager.getJWK();
         const accessToken = this.instanceManager.getAccessToken()?.token;
         const refreshToken = this.instanceManager.getRefreshToken();
         if (!accessToken || !refreshToken || !jwk) {
-            throw new OpenfortError('Must be logged in to validate and refresh token', OpenfortErrorType.NOT_LOGGED_IN_ERROR);
+            throw new OpenfortError('Must be logged in to validate and refresh token', exports.OpenfortErrorType.NOT_LOGGED_IN_ERROR);
         }
         if (forceRefresh) {
             return this.refreshTokens(refreshToken, forceRefresh);
@@ -5022,7 +5041,7 @@ class AuthManager {
                 accessToken: response.data.token,
                 refreshToken: response.data.refreshToken,
             };
-        }, OpenfortErrorType.REFRESH_TOKEN_ERROR);
+        }, { default: exports.OpenfortErrorType.REFRESH_TOKEN_ERROR });
     }
     async logout(accessToken, refreshToken) {
         const request = {
@@ -5038,7 +5057,7 @@ class AuthManager {
                     'x-player-token': accessToken,
                 },
             });
-        }, OpenfortErrorType.LOGOUT_ERROR);
+        }, { default: exports.OpenfortErrorType.LOGOUT_ERROR });
     }
     async getUser(accessToken) {
         // TODO: Add storage of user info
@@ -5051,7 +5070,7 @@ class AuthManager {
         });
         return response.data;
     }
-    async linkOAuth(provider, playerToken, options) {
+    async linkOAuth(provider, playerToken, options, ecosystemGame) {
         const request = {
             oAuthInitRequest: {
                 provider,
@@ -5064,6 +5083,8 @@ class AuthManager {
                 authorization: `Bearer ${this.config.baseConfiguration.publishableKey}`,
                 // eslint-disable-next-line @typescript-eslint/naming-convention
                 'x-player-token': playerToken,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-game': ecosystemGame || undefined,
             },
         });
         if (isBrowser() && !options?.skipBrowserRedirect) {
@@ -5137,7 +5158,7 @@ class AuthManager {
         });
         return authPlayerResponse.data;
     }
-    async linkEmail(email, password, accessToken) {
+    async linkEmail(email, password, accessToken, ecosystemGame) {
         const request = {
             loginRequest: {
                 email,
@@ -5149,12 +5170,161 @@ class AuthManager {
                 authorization: `Bearer ${this.config.baseConfiguration.publishableKey}`,
                 // eslint-disable-next-line @typescript-eslint/naming-convention
                 'x-player-token': accessToken,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-game': ecosystemGame || undefined,
             },
         });
         return authPlayerResponse.data;
     }
 }
 
+var Event;
+(function (Event) {
+    Event["LOADED"] = "loaded";
+    Event["CONFIGURE"] = "configure";
+    Event["CONFIGURED"] = "configured";
+    Event["UPDATE_AUTHENTICATION"] = "update-authentication";
+    Event["AUTHENTICATION_UPDATED"] = "authentication-updated";
+    Event["SIGN"] = "sign";
+    Event["SIGNED"] = "signed";
+    Event["LOGOUT"] = "logout";
+    Event["LOGGED_OUT"] = "logged-out";
+    Event["GET_CURRENT_DEVICE"] = "get-current-device";
+    Event["CURRENT_DEVICE"] = "current-device";
+    Event["PING"] = "ping";
+    Event["PONG"] = "pong";
+})(Event || (Event = {}));
+const NOT_CONFIGURED_ERROR = 'not-configured-error';
+const MISSING_USER_ENTROPY_ERROR = 'missing-user-entropy-error';
+const INCORRECT_USER_ENTROPY_ERROR = 'incorrect-user-entropy-error';
+class GetCurrentDeviceRequest {
+    uuid;
+    action = Event.GET_CURRENT_DEVICE;
+    playerID;
+    constructor(uuid, playerId) {
+        this.uuid = uuid;
+        this.playerID = playerId;
+    }
+}
+class PingRequest {
+    uuid;
+    action = Event.PING;
+    constructor(uuid) {
+        this.uuid = uuid;
+    }
+}
+class GetCurrentDeviceResponse {
+    uuid;
+    success;
+    action = Event.CURRENT_DEVICE;
+    deviceID;
+    accountType;
+    version = null;
+    chainId;
+    address;
+    constructor(uuid, deviceID, accountType, chainId, address) {
+        this.uuid = uuid;
+        this.success = true;
+        this.deviceID = deviceID;
+        this.accountType = accountType;
+        this.chainId = chainId;
+        this.address = address;
+    }
+}
+class LogoutRequest {
+    uuid;
+    action = Event.LOGOUT;
+    constructor(uuid) {
+        this.uuid = uuid;
+    }
+}
+class SignRequest {
+    uuid;
+    action = Event.SIGN;
+    message;
+    requireArrayify;
+    requireHash;
+    requestConfiguration;
+    constructor(uuid, message, requireArrayify, requireHash, requestConfiguration) {
+        this.uuid = uuid;
+        this.message = message;
+        this.requireArrayify = requireArrayify;
+        this.requireHash = requireHash;
+        this.requestConfiguration = requestConfiguration;
+    }
+}
+function isErrorResponse(response) {
+    return 'error' in response;
+}
+class ConfigureResponse {
+    uuid;
+    success;
+    deviceID;
+    address;
+    chainId;
+    accountType;
+    action = Event.CONFIGURED;
+    version;
+    constructor(uuid, deviceID, accountType, chainId, address) {
+        this.success = true;
+        this.deviceID = deviceID;
+        this.uuid = uuid;
+        this.accountType = accountType;
+        this.chainId = chainId;
+        this.address = address;
+        this.version = null;
+    }
+}
+class UpdateAuthenticationResponse {
+    uuid;
+    success;
+    action = Event.AUTHENTICATION_UPDATED;
+    version;
+    constructor(uuid) {
+        this.success = true;
+        this.uuid = uuid;
+        this.version = null;
+    }
+}
+class SignResponse {
+    uuid;
+    success;
+    signature;
+    action = Event.SIGNED;
+    version;
+    constructor(uuid, signature) {
+        this.success = true;
+        this.signature = signature;
+        this.uuid = uuid;
+        this.version = null;
+    }
+}
+class LogoutResponse {
+    uuid;
+    success;
+    action = Event.LOGGED_OUT;
+    constructor(uuid) {
+        this.success = true;
+        this.uuid = uuid;
+    }
+}
+class UpdateAuthenticationRequest {
+    uuid;
+    action = Event.UPDATE_AUTHENTICATION;
+    accessToken;
+    recovery;
+    constructor(uuid, accessToken, recovery) {
+        this.uuid = uuid;
+        this.accessToken = accessToken;
+        this.recovery = recovery;
+    }
+}
+exports.ShieldAuthType = void 0;
+(function (ShieldAuthType) {
+    ShieldAuthType["OPENFORT"] = "openfort";
+    ShieldAuthType["CUSTOM"] = "custom";
+})(exports.ShieldAuthType || (exports.ShieldAuthType = {}));
+
 const authTokenStorageKey = 'openfort.auth_token';
 const thirdPartyProviderStorageKey = 'openfort.third_party_provider';
 const thirdPartyProviderTokenTypeStorageKey = 'openfort.third_party_provider_token_type';
@@ -5404,6 +5574,11 @@ class InstanceManager {
     getShieldAuthType() {
         if (!this.accountType) {
             this.accountType = this.persistentStorage.get(shieldAuthTypeStorageKey);
+            if (this.accountType === null) {
+                // TODO: remove, this is for backward compatibility
+                this.setShieldAuthType(exports.ShieldAuthType.OPENFORT);
+                this.accountType = exports.ShieldAuthType.OPENFORT;
+            }
         }
         return this.accountType;
     }
@@ -5554,7 +5729,8 @@ class EmbeddedSigner {
         if (!accessToken) {
             return;
         }
-        await this.iframeManager.updateAuthentication(this.iframeConfiguration, accessToken.token);
+        const shieldAuthType = this.instanceManager.getShieldAuthType();
+        await this.iframeManager.updateAuthentication(this.iframeConfiguration, accessToken.token, shieldAuthType);
     }
     // eslint-disable-next-line class-methods-use-this
     getSingerType() {
@@ -5629,153 +5805,6 @@ class SessionStorage {
     }
 }
 
-var Event;
-(function (Event) {
-    Event["LOADED"] = "loaded";
-    Event["CONFIGURE"] = "configure";
-    Event["CONFIGURED"] = "configured";
-    Event["UPDATE_AUTHENTICATION"] = "update-authentication";
-    Event["AUTHENTICATION_UPDATED"] = "authentication-updated";
-    Event["SIGN"] = "sign";
-    Event["SIGNED"] = "signed";
-    Event["LOGOUT"] = "logout";
-    Event["LOGGED_OUT"] = "logged-out";
-    Event["GET_CURRENT_DEVICE"] = "get-current-device";
-    Event["CURRENT_DEVICE"] = "current-device";
-    Event["PING"] = "ping";
-    Event["PONG"] = "pong";
-})(Event || (Event = {}));
-const NOT_CONFIGURED_ERROR = 'not-configured-error';
-const MISSING_USER_ENTROPY_ERROR = 'missing-user-entropy-error';
-const INCORRECT_USER_ENTROPY_ERROR = 'incorrect-user-entropy-error';
-class GetCurrentDeviceRequest {
-    uuid;
-    action = Event.GET_CURRENT_DEVICE;
-    playerID;
-    constructor(uuid, playerId) {
-        this.uuid = uuid;
-        this.playerID = playerId;
-    }
-}
-class PingRequest {
-    uuid;
-    action = Event.PING;
-    constructor(uuid) {
-        this.uuid = uuid;
-    }
-}
-class GetCurrentDeviceResponse {
-    uuid;
-    success;
-    action = Event.CURRENT_DEVICE;
-    deviceID;
-    accountType;
-    version = null;
-    chainId;
-    address;
-    constructor(uuid, deviceID, accountType, chainId, address) {
-        this.uuid = uuid;
-        this.success = true;
-        this.deviceID = deviceID;
-        this.accountType = accountType;
-        this.chainId = chainId;
-        this.address = address;
-    }
-}
-class LogoutRequest {
-    uuid;
-    action = Event.LOGOUT;
-    constructor(uuid) {
-        this.uuid = uuid;
-    }
-}
-class SignRequest {
-    uuid;
-    action = Event.SIGN;
-    message;
-    requireArrayify;
-    requireHash;
-    requestConfiguration;
-    constructor(uuid, message, requireArrayify, requireHash, requestConfiguration) {
-        this.uuid = uuid;
-        this.message = message;
-        this.requireArrayify = requireArrayify;
-        this.requireHash = requireHash;
-        this.requestConfiguration = requestConfiguration;
-    }
-}
-function isErrorResponse(response) {
-    return 'error' in response;
-}
-class ConfigureResponse {
-    uuid;
-    success;
-    deviceID;
-    address;
-    chainId;
-    accountType;
-    action = Event.CONFIGURED;
-    version;
-    constructor(uuid, deviceID, accountType, chainId, address) {
-        this.success = true;
-        this.deviceID = deviceID;
-        this.uuid = uuid;
-        this.accountType = accountType;
-        this.chainId = chainId;
-        this.address = address;
-        this.version = null;
-    }
-}
-class UpdateAuthenticationResponse {
-    uuid;
-    success;
-    action = Event.AUTHENTICATION_UPDATED;
-    version;
-    constructor(uuid) {
-        this.success = true;
-        this.uuid = uuid;
-        this.version = null;
-    }
-}
-class SignResponse {
-    uuid;
-    success;
-    signature;
-    action = Event.SIGNED;
-    version;
-    constructor(uuid, signature) {
-        this.success = true;
-        this.signature = signature;
-        this.uuid = uuid;
-        this.version = null;
-    }
-}
-class LogoutResponse {
-    uuid;
-    success;
-    action = Event.LOGGED_OUT;
-    constructor(uuid) {
-        this.success = true;
-        this.uuid = uuid;
-    }
-}
-class UpdateAuthenticationRequest {
-    uuid;
-    action = Event.UPDATE_AUTHENTICATION;
-    accessToken;
-    recovery;
-    constructor(uuid, accessToken, recovery) {
-        this.uuid = uuid;
-        this.accessToken = accessToken;
-        this.recovery = recovery;
-    }
-}
-exports.ShieldAuthType = void 0;
-(function (ShieldAuthType) {
-    ShieldAuthType["OPENFORT"] = "openfort";
-    ShieldAuthType["CUSTOM"] = "custom";
-})(exports.ShieldAuthType || (exports.ShieldAuthType = {}));
-
 class MissingRecoveryPasswordError extends Error {
     constructor() {
         super('This embedded signer requires a password to be recovered');
@@ -5979,9 +6008,13 @@ class IframeManager {
         this.iframe?.contentWindow?.postMessage(request, '*');
         await this.waitForResponse(uuid);
     }
-    async updateAuthentication(iframeConfiguration, token) {
+    async updateAuthentication(iframeConfiguration, token, shieldAuthType) {
         // eslint-disable-next-line no-param-reassign
         iframeConfiguration.accessToken = token;
+        if (shieldAuthType === exports.ShieldAuthType.OPENFORT && iframeConfiguration.recovery) {
+            // eslint-disable-next-line no-param-reassign
+            iframeConfiguration.recovery.token = token;
+        }
         await this.waitForIframeLoad();
         const uuid = this.generateShortUUID();
         const request = new UpdateAuthenticationRequest(uuid, token);
@@ -5992,7 +6025,7 @@ class IframeManager {
         catch (e) {
             if (e instanceof NotConfiguredError) {
                 await this.configure(iframeConfiguration);
-                await this.updateAuthentication(iframeConfiguration, token);
+                await this.updateAuthentication(iframeConfiguration, token, shieldAuthType);
                 return;
             }
             throw e;
@@ -6068,7 +6101,7 @@ class Openfort {
      */
     getEthereumProvider(options = { announceProvider: true }) {
         if (!(this.signer instanceof EmbeddedSigner)) {
-            throw new OpenfortError('Embedded signer must be configured to get Ethereum provider', OpenfortErrorType.NOT_LOGGED_IN_ERROR);
+            throw new OpenfortError('Embedded signer must be configured to get Ethereum provider', exports.OpenfortErrorType.NOT_LOGGED_IN_ERROR);
         }
         const address = this.instanceManager.getAccountAddress();
         const provider = new EvmProvider({
@@ -6094,7 +6127,7 @@ class Openfort {
      */
     configureSessionKey() {
         if (this.instanceManager.getSignerType() === SignerType.EMBEDDED) {
-            throw new OpenfortError('Session signer must be configured to sign a session', OpenfortErrorType.MISSING_SESSION_SIGNER_ERROR);
+            throw new OpenfortError('Session signer must be configured to sign a session', exports.OpenfortErrorType.MISSING_SESSION_SIGNER_ERROR);
         }
         const signer = new SessionSigner(this.instanceManager);
         this.signer = signer;
@@ -6131,11 +6164,12 @@ class Openfort {
      *
      * @param email - User's email.
      * @param password - User's password.
+     * @param ecosystemGame - In case of ecosystem, the game that wants to authenticate.
      * @returns An AuthResponse object containing authentication details.
      */
-    async logInWithEmailPassword({ email, password }) {
+    async logInWithEmailPassword({ email, password, ecosystemGame }) {
         this.logout();
-        const result = await this.authManager.loginEmailPassword(email, password);
+        const result = await this.authManager.loginEmailPassword(email, password, ecosystemGame);
         this.storeCredentials({
             player: result.player.id,
             accessToken: result.token,
@@ -6149,11 +6183,12 @@ class Openfort {
      * @param email - User's email.
      * @param password - User's password.
      * @param options - Additional options for the sign-up process.
+     * @param ecosystemGame - In case of ecosystem, the game that wants to authenticate.
      * @returns An AuthResponse object containing authentication details.
      */
-    async signUpWithEmailPassword({ email, password, options }) {
+    async signUpWithEmailPassword({ email, password, options, ecosystemGame, }) {
         this.logout();
-        const result = await this.authManager.signupEmailPassword(email, password, options?.data.name);
+        const result = await this.authManager.signupEmailPassword(email, password, options?.data.name, ecosystemGame);
         this.storeCredentials({
             player: result.player.id,
             accessToken: result.token,
@@ -6167,11 +6202,11 @@ class Openfort {
      * @param email - User's email.
      * @param password - User's password.
      * @param authToken - Authentication token.
+     * @param ecosystemGame - In case of ecosystem, the game that wants to authenticate.
      * @returns An AuthPlayerResponse object.
      */
-    async linkEmailPassword({ email, password, authToken }) {
-        const result = await this.authManager.linkEmail(email, password, authToken);
-        return result;
+    async linkEmailPassword({ email, password, authToken, ecosystemGame, }) {
+        return await this.authManager.linkEmail(email, password, authToken, ecosystemGame);
     }
     /**
      * Unlinks an email and password from an existing account using an authentication token.
@@ -6181,8 +6216,7 @@ class Openfort {
      * @returns An AuthPlayerResponse object.
      */
     async unlinkEmailPassword({ email, authToken }) {
-        const result = await this.authManager.unlinkEmail(email, authToken);
-        return result;
+        return await this.authManager.unlinkEmail(email, authToken);
     }
     /**
      * Requests an email verification link.
@@ -6226,12 +6260,12 @@ class Openfort {
      *
      * @param provider - OAuth provider.
      * @param options - Additional options for initialization.
+     * @param ecosystemGame - In case of ecosystem, the game that wants to authenticate.
      * @returns An InitAuthResponse object.
      */
-    async initOAuth({ provider, options }) {
+    async initOAuth({ provider, options, ecosystemGame }) {
         this.logout();
-        const authResponse = await this.authManager.initOAuth(provider, options);
-        return authResponse;
+        return await this.authManager.initOAuth(provider, options, ecosystemGame);
     }
     /**
      * Initializes an OAuth linking process.
@@ -6239,10 +6273,11 @@ class Openfort {
      * @param provider - OAuth provider.
      * @param authToken - Authentication token.
      * @param options - Additional options for initialization.
+     * @param ecosystemGame - In case of ecosystem, the game that wants to authenticate.
      * @returns An InitAuthResponse object.
      */
-    async initLinkOAuth({ provider, authToken, options }) {
-        return await this.authManager.linkOAuth(provider, authToken, options);
+    async initLinkOAuth({ provider, authToken, options, ecosystemGame, }) {
+        return await this.authManager.linkOAuth(provider, authToken, options, ecosystemGame);
     }
     /**
      * Unlinks an OAuth provider from the account.
@@ -6252,8 +6287,7 @@ class Openfort {
      * @returns An AuthPlayerResponse object.
      */
     async unlinkOAuth({ provider, authToken }) {
-        const result = await this.authManager.unlinkOAuth(provider, authToken);
-        return result;
+        return await this.authManager.unlinkOAuth(provider, authToken);
     }
     /**
      * Polls for OAuth authentication completion.
@@ -6270,10 +6304,11 @@ class Openfort {
      * @param provider - Third-party OAuth provider.
      * @param token - OAuth token.
      * @param tokenType - Type of the OAuth token.
+     * @param ecosystemGame - In case of ecosystem, the game that wants to authenticate.
      * @returns An AuthPlayerResponse object.
      */
-    async authenticateWithThirdPartyProvider({ provider, token, tokenType }) {
-        const result = await this.authManager.authenticateThirdParty(provider, token, tokenType);
+    async authenticateWithThirdPartyProvider({ provider, token, tokenType, ecosystemGame, }) {
+        const result = await this.authManager.authenticateThirdParty(provider, token, tokenType, ecosystemGame);
         this.instanceManager.setAccessToken({
             token,
             thirdPartyProvider: provider,
@@ -6289,10 +6324,11 @@ class Openfort {
      * Initializes Sign-In with Ethereum (SIWE).
      *
      * @param address - Ethereum address.
+     * @param ecosystemGame - In case of ecosystem, the game that wants to authenticate.
      * @returns A SIWEInitResponse object.
      */
-    async initSIWE({ address }) {
-        return await this.authManager.initSIWE(address);
+    async initSIWE({ address, ecosystemGame }) {
+        return await this.authManager.initSIWE(address, ecosystemGame);
     }
     /**
      * Authenticates using Sign-In with Ethereum (SIWE).
@@ -6326,8 +6362,7 @@ class Openfort {
      * @returns An AuthPlayerResponse object.
      */
     async linkWallet({ signature, message, walletClientType, connectorType, authToken, }) {
-        const result = await this.authManager.linkWallet(signature, message, walletClientType, connectorType, authToken);
-        return result;
+        return await this.authManager.linkWallet(signature, message, walletClientType, connectorType, authToken);
     }
     /**
      * Unlinks a wallet.
@@ -6337,8 +6372,7 @@ class Openfort {
      * @returns An AuthPlayerResponse object.
      */
     async unlinkWallet({ address, authToken }) {
-        const result = await this.authManager.unlinkWallet(address, authToken);
-        return result;
+        return await this.authManager.unlinkWallet(address, authToken);
     }
     /**
      * Stores authentication credentials.
@@ -6369,11 +6403,11 @@ class Openfort {
         let newSignature = signature;
         if (!newSignature) {
             if (!userOperationHash) {
-                throw new OpenfortError('No userOperationHash or signature provided', OpenfortErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+                throw new OpenfortError('No userOperationHash or signature provided', exports.OpenfortErrorType.OPERATION_NOT_SUPPORTED_ERROR);
             }
             await this.recoverSigner();
             if (!this.signer) {
-                throw new OpenfortError('In order to sign a transaction intent, a signer must be configured', OpenfortErrorType.MISSING_SIGNER_ERROR);
+                throw new OpenfortError('In order to sign a transaction intent, a signer must be configured', exports.OpenfortErrorType.MISSING_SIGNER_ERROR);
             }
             if (this.signer.useCredentials()) {
                 await this.validateAndRefreshToken();
@@ -6401,7 +6435,7 @@ class Openfort {
     async signMessage(message, options) {
         await this.recoverSigner();
         if (!this.signer) {
-            throw new OpenfortError('In order to sign a message, an embedded signer must be configured', OpenfortErrorType.MISSING_EMBEDDED_SIGNER_ERROR);
+            throw new OpenfortError('In order to sign a message, an embedded signer must be configured', exports.OpenfortErrorType.MISSING_EMBEDDED_SIGNER_ERROR);
         }
         if (this.signer.useCredentials()) {
             await this.validateAndRefreshToken();
@@ -6421,7 +6455,7 @@ class Openfort {
     async signTypedData(domain, types, value) {
         await this.recoverSigner();
         if (!this.signer) {
-            throw new OpenfortError('In order to sign a message, an embedded signer must be configured', OpenfortErrorType.MISSING_EMBEDDED_SIGNER_ERROR);
+            throw new OpenfortError('In order to sign a message, an embedded signer must be configured', exports.OpenfortErrorType.MISSING_EMBEDDED_SIGNER_ERROR);
         }
         if (this.signer.useCredentials()) {
             await this.validateAndRefreshToken();
@@ -6508,7 +6542,7 @@ class Openfort {
         await this.validateAndRefreshToken();
         const accessToken = this.instanceManager.getAccessToken();
         if (!accessToken) {
-            throw new OpenfortError('No accessToken found', OpenfortErrorType.NOT_LOGGED_IN_ERROR);
+            throw new OpenfortError('No accessToken found', exports.OpenfortErrorType.NOT_LOGGED_IN_ERROR);
         }
         return await this.authManager.getUser(accessToken.token);
     }
@@ -6518,7 +6552,7 @@ class Openfort {
     async validateAndRefreshToken(forceRefresh) {
         const authType = this.credentialsProvided();
         if (!authType) {
-            throw new OpenfortError('Must be logged in to validate and refresh token', OpenfortErrorType.NOT_LOGGED_IN_ERROR);
+            throw new OpenfortError('Must be logged in to validate and refresh token', exports.OpenfortErrorType.NOT_LOGGED_IN_ERROR);
         }
         if (authType === exports.AuthType.OPENFORT) {
             const auth = await this.authManager.validateCredentials(forceRefresh);
@@ -6577,20 +6611,14 @@ class Openfort {
     }
     newEmbeddedSigner(chainId) {
         if (!this.credentialsProvided()) {
-            throw new OpenfortError('Must be logged in to configure embedded signer', OpenfortErrorType.NOT_LOGGED_IN_ERROR);
-        }
-        let shieldAuthType = this.instanceManager.getShieldAuthType();
-        if (!shieldAuthType) {
-            // TODO: remove, this is for backward compatibility
-            this.instanceManager.setShieldAuthType(exports.ShieldAuthType.OPENFORT);
-            shieldAuthType = exports.ShieldAuthType.OPENFORT;
-            // throw new OpenfortError('Shield auth type is not set', OpenfortErrorType.INVALID_CONFIGURATION);
+            throw new OpenfortError('Must be logged in to configure embedded signer', exports.OpenfortErrorType.NOT_LOGGED_IN_ERROR);
         }
+        const shieldAuthType = this.instanceManager.getShieldAuthType();
         const token = shieldAuthType === exports.ShieldAuthType.OPENFORT
             ? this.instanceManager.getAccessToken()?.token
             : this.instanceManager.getShieldAuthToken();
         if (!token) {
-            throw new OpenfortError('Shield auth token is not set', OpenfortErrorType.INVALID_CONFIGURATION);
+            throw new OpenfortError('Shield auth token is not set', exports.OpenfortErrorType.INVALID_CONFIGURATION);
         }
         const shieldAuth = {
             auth: shieldAuthType,