@openfort/openfort-js 0.7.7 → 0.7.9

package/dist/index.cjs

@@ -33,60 +33,6 @@ function _interopNamespaceDefault(e) {
 
 var crypto__namespace = /*#__PURE__*/_interopNamespaceDefault(crypto);
 
-exports.EmbeddedState = void 0;
-(function (EmbeddedState) {
-    EmbeddedState[EmbeddedState["NONE"] = 0] = "NONE";
-    EmbeddedState[EmbeddedState["UNAUTHENTICATED"] = 1] = "UNAUTHENTICATED";
-    EmbeddedState[EmbeddedState["EMBEDDED_SIGNER_NOT_CONFIGURED"] = 2] = "EMBEDDED_SIGNER_NOT_CONFIGURED";
-    EmbeddedState[EmbeddedState["CREATING_ACCOUNT"] = 3] = "CREATING_ACCOUNT";
-    EmbeddedState[EmbeddedState["READY"] = 4] = "READY";
-})(exports.EmbeddedState || (exports.EmbeddedState = {}));
-var OpenfortEvents;
-(function (OpenfortEvents) {
-    OpenfortEvents["LOGGED_OUT"] = "loggedOut";
-})(OpenfortEvents || (OpenfortEvents = {}));
-var AccountType;
-(function (AccountType) {
-    AccountType["UPGRADEABLE_V4"] = "Upgradeable_v04";
-    AccountType["MANAGED_V4"] = "Managed_v04";
-    AccountType["ERC6551_V4"] = "ERC6551_v04";
-    AccountType["ERC6551_V5"] = "ERC6551_v05";
-    AccountType["RECOVERABLE_V4"] = "Recoverable_v04";
-    AccountType["MANAGED_V5"] = "Managed_v05";
-    AccountType["UPGRADEABLE_V5"] = "Upgradeable_v05";
-})(AccountType || (AccountType = {}));
-exports.TokenType = void 0;
-(function (TokenType) {
-    TokenType["ID_TOKEN"] = "idToken";
-    TokenType["CUSTOM_TOKEN"] = "customToken";
-})(exports.TokenType || (exports.TokenType = {}));
-exports.ThirdPartyOAuthProvider = void 0;
-(function (ThirdPartyOAuthProvider) {
-    ThirdPartyOAuthProvider["ACCELBYTE"] = "accelbyte";
-    ThirdPartyOAuthProvider["FIREBASE"] = "firebase";
-    ThirdPartyOAuthProvider["LOOTLOCKER"] = "lootlocker";
-    ThirdPartyOAuthProvider["PLAYFAB"] = "playfab";
-    ThirdPartyOAuthProvider["SUPABASE"] = "supabase";
-    ThirdPartyOAuthProvider["CUSTOM"] = "custom";
-    ThirdPartyOAuthProvider["OIDC"] = "oidc";
-})(exports.ThirdPartyOAuthProvider || (exports.ThirdPartyOAuthProvider = {}));
-exports.BasicAuthProvider = void 0;
-(function (BasicAuthProvider) {
-    BasicAuthProvider["EMAIL"] = "email";
-    BasicAuthProvider["WALLET"] = "wallet";
-})(exports.BasicAuthProvider || (exports.BasicAuthProvider = {}));
-exports.OAuthProvider = void 0;
-(function (OAuthProvider) {
-    OAuthProvider["GOOGLE"] = "google";
-    OAuthProvider["TWITTER"] = "twitter";
-    OAuthProvider["FACEBOOK"] = "facebook";
-})(exports.OAuthProvider || (exports.OAuthProvider = {}));
-var CodeChallengeMethodEnum;
-(function (CodeChallengeMethodEnum) {
-    CodeChallengeMethodEnum["PLAIN"] = "plain";
-    CodeChallengeMethodEnum["S256"] = "S256";
-})(CodeChallengeMethodEnum || (CodeChallengeMethodEnum = {}));
-
 /* tslint:disable */
 /* eslint-disable */
 /**
@@ -3090,6 +3036,65 @@ const createConfig = ({ basePath, accessToken, }) => {
     return new Configuration(apiConfigOptions);
 };
 
+exports.EmbeddedState = void 0;
+(function (EmbeddedState) {
+    EmbeddedState[EmbeddedState["NONE"] = 0] = "NONE";
+    EmbeddedState[EmbeddedState["UNAUTHENTICATED"] = 1] = "UNAUTHENTICATED";
+    EmbeddedState[EmbeddedState["EMBEDDED_SIGNER_NOT_CONFIGURED"] = 2] = "EMBEDDED_SIGNER_NOT_CONFIGURED";
+    EmbeddedState[EmbeddedState["CREATING_ACCOUNT"] = 3] = "CREATING_ACCOUNT";
+    EmbeddedState[EmbeddedState["READY"] = 4] = "READY";
+})(exports.EmbeddedState || (exports.EmbeddedState = {}));
+var OpenfortEvents;
+(function (OpenfortEvents) {
+    OpenfortEvents["LOGGED_OUT"] = "loggedOut";
+})(OpenfortEvents || (OpenfortEvents = {}));
+var AccountType;
+(function (AccountType) {
+    AccountType["UPGRADEABLE_V4"] = "Upgradeable_v04";
+    AccountType["MANAGED_V4"] = "Managed_v04";
+    AccountType["ERC6551_V4"] = "ERC6551_v04";
+    AccountType["ERC6551_V5"] = "ERC6551_v05";
+    AccountType["RECOVERABLE_V4"] = "Recoverable_v04";
+    AccountType["MANAGED_V5"] = "Managed_v05";
+    AccountType["UPGRADEABLE_V5"] = "Upgradeable_v05";
+})(AccountType || (AccountType = {}));
+exports.AuthType = void 0;
+(function (AuthType) {
+    AuthType["OPENFORT"] = "openfort";
+    AuthType["THIRD_PARTY"] = "thirdParty";
+})(exports.AuthType || (exports.AuthType = {}));
+exports.TokenType = void 0;
+(function (TokenType) {
+    TokenType["ID_TOKEN"] = "idToken";
+    TokenType["CUSTOM_TOKEN"] = "customToken";
+})(exports.TokenType || (exports.TokenType = {}));
+exports.ThirdPartyOAuthProvider = void 0;
+(function (ThirdPartyOAuthProvider) {
+    ThirdPartyOAuthProvider["ACCELBYTE"] = "accelbyte";
+    ThirdPartyOAuthProvider["FIREBASE"] = "firebase";
+    ThirdPartyOAuthProvider["LOOTLOCKER"] = "lootlocker";
+    ThirdPartyOAuthProvider["PLAYFAB"] = "playfab";
+    ThirdPartyOAuthProvider["SUPABASE"] = "supabase";
+    ThirdPartyOAuthProvider["CUSTOM"] = "custom";
+    ThirdPartyOAuthProvider["OIDC"] = "oidc";
+})(exports.ThirdPartyOAuthProvider || (exports.ThirdPartyOAuthProvider = {}));
+exports.BasicAuthProvider = void 0;
+(function (BasicAuthProvider) {
+    BasicAuthProvider["EMAIL"] = "email";
+    BasicAuthProvider["WALLET"] = "wallet";
+})(exports.BasicAuthProvider || (exports.BasicAuthProvider = {}));
+exports.OAuthProvider = void 0;
+(function (OAuthProvider) {
+    OAuthProvider["GOOGLE"] = "google";
+    OAuthProvider["TWITTER"] = "twitter";
+    OAuthProvider["FACEBOOK"] = "facebook";
+})(exports.OAuthProvider || (exports.OAuthProvider = {}));
+var CodeChallengeMethodEnum;
+(function (CodeChallengeMethodEnum) {
+    CodeChallengeMethodEnum["PLAIN"] = "plain";
+    CodeChallengeMethodEnum["S256"] = "S256";
+})(CodeChallengeMethodEnum || (CodeChallengeMethodEnum = {}));
+
 var OpenfortErrorType;
 (function (OpenfortErrorType) {
     OpenfortErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
@@ -4624,8 +4629,8 @@ class EvmProvider {
 const openfortProviderInfo = {
     // eslint-disable-next-line max-len
     icon: 'data:image/svg+xml,<svg aria-hidden="true" viewBox="597.32 331.34 171.36 105.32" ><g><rect x="673.9" y="404.26" width="18.2" height="32.4" /><polygon points="768.68,331.36 768.68,331.36 768.68,331.34 610.78,331.34 610.78,331.36 597.32,331.36 597.32,436.64    615.52,436.64 615.52,349.54 750.48,349.54 750.48,436.64 768.68,436.64  " /><polygon points="732.16,367.79 633.83,367.79 633.83,370.19 633.79,370.19 633.79,436.64 651.99,436.64 651.99,385.99    713.9,385.99 713.9,436.64 732.09,436.64 732.09,385.99 732.16,385.99  " /></g></svg>',
-    name: 'Ecosystem ID',
-    rdns: 'com.ecosystem.id',
+    name: 'Openfort',
+    rdns: 'xyz.openfort',
     uuid: uuid.v4(),
 };
 function announceProvider(detail) {
@@ -4683,11 +4688,14 @@ class AuthManager {
         this.instanceManager = instanceManager;
     }
     async initOAuth(provider, options) {
+        const usePooling = options?.usePooling ?? false;
+        // eslint-disable-next-line no-param-reassign
+        delete options?.usePooling;
         const request = {
             oAuthInitRequest: {
                 provider,
                 options,
-                usePooling: options?.usePooling || false,
+                usePooling,
             },
         };
         const result = await this.backendApiClients.authenticationApi.initOAuth(request);
@@ -4869,7 +4877,13 @@ class AuthManager {
             return response.data;
         }, OpenfortErrorType.USER_REGISTRATION_ERROR);
     }
-    async validateCredentials(accessToken, refreshToken, jwk) {
+    async validateCredentials() {
+        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);
+        }
         try {
             const key = (await jose.importJWK({
                 kty: jwk.kty,
@@ -5045,6 +5059,8 @@ const chainIDStorageKey = 'openfort.chain_id';
 const jwksStorageKey = 'openfort.jwk';
 const deviceIDStorageKey = 'openfort.device_id';
 const accountTypeStorageKey = 'openfort.account_type';
+const shieldAuthTypeStorageKey = 'openfort.shield_auth_type';
+const shieldAuthTokenStorageKey = 'openfort.shield_auth_token';
 const accountAddressStorageKey = 'openfort.account_address';
 
 class InstanceManager {
@@ -5054,6 +5070,7 @@ class InstanceManager {
     jwk = null;
     sessionKey = null;
     deviceID = null;
+    shieldAuthType = null;
     chainId = null;
     accountAddress = null;
     accountType = null;
@@ -5185,9 +5202,10 @@ class InstanceManager {
             };
             const response = await this.backendApiClients.authenticationApi.getJwks(request);
             if (response.data.keys.length === 0) {
-                throw new Error('No keys found');
+                throw new Error('Internal error: No JWKS keys found');
             }
             const jwtKey = response.data.keys[0];
+            this.setJWK(jwtKey);
             this.jwk = {
                 kty: jwtKey.kty,
                 crv: jwtKey.crv,
@@ -5272,6 +5290,34 @@ class InstanceManager {
         this.accountType = null;
         this.persistentStorage.remove(accountTypeStorageKey);
     }
+    setShieldAuthType(accountType) {
+        this.accountType = accountType;
+        this.persistentStorage.save(shieldAuthTypeStorageKey, accountType);
+    }
+    getShieldAuthType() {
+        if (!this.accountType) {
+            this.accountType = this.persistentStorage.get(shieldAuthTypeStorageKey);
+        }
+        return this.accountType;
+    }
+    removeShieldAuthType() {
+        this.accountType = null;
+        this.persistentStorage.remove(shieldAuthTypeStorageKey);
+    }
+    setShieldAuthToken(accountType) {
+        this.accountType = accountType;
+        this.persistentStorage.save(shieldAuthTokenStorageKey, accountType);
+    }
+    getShieldAuthToken() {
+        if (!this.accountType) {
+            this.accountType = this.persistentStorage.get(shieldAuthTokenStorageKey);
+        }
+        return this.accountType;
+    }
+    removeShieldAuthToken() {
+        this.accountType = null;
+        this.persistentStorage.remove(shieldAuthTokenStorageKey);
+    }
 }
 
 class LocalStorage {
@@ -5617,11 +5663,11 @@ class UpdateAuthenticationRequest {
         this.recovery = recovery;
     }
 }
-exports.AuthType = void 0;
-(function (AuthType) {
-    AuthType["OPENFORT"] = "openfort";
-    AuthType["CUSTOM"] = "custom";
-})(exports.AuthType || (exports.AuthType = {}));
+exports.ShieldAuthType = void 0;
+(function (ShieldAuthType) {
+    ShieldAuthType["OPENFORT"] = "openfort";
+    ShieldAuthType["CUSTOM"] = "custom";
+})(exports.ShieldAuthType || (exports.ShieldAuthType = {}));
 
 class MissingRecoveryPasswordError extends Error {
     constructor() {
@@ -5872,6 +5918,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()) {
@@ -5899,11 +5948,18 @@ class Openfort {
             this.instanceManager.removeChainID();
             this.instanceManager.removeDeviceID();
             this.instanceManager.removeJWK();
+            this.instanceManager.removeShieldAuthType();
+            this.instanceManager.removeShieldAuthToken();
         }
     }
-    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 OpenfortError('Embedded signer must be configured to get Ethereum provider', OpenfortErrorType.NOT_LOGGED_IN_ERROR);
         }
@@ -5924,33 +5980,15 @@ 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() {
+        if (this.instanceManager.getSignerType() === SignerType.EMBEDDED) {
+            throw new OpenfortError('Session signer must be configured to sign a session', OpenfortErrorType.MISSING_SESSION_SIGNER_ERROR);
+        }
         const signer = new SessionSigner(this.instanceManager);
         this.signer = signer;
         const publicKey = signer.loadKeys();
@@ -5961,30 +5999,35 @@ 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();
+        if (shieldAuthentication) {
+            this.instanceManager.setShieldAuthType(shieldAuthentication?.auth);
+            if (shieldAuthentication?.auth === exports.ShieldAuthType.CUSTOM) {
+                this.instanceManager.setShieldAuthToken(shieldAuthentication?.token);
+            }
+        }
+        const signer = this.newEmbeddedSigner(chainId);
         await signer.ensureEmbeddedAccount(recoveryPassword);
         this.signer = signer;
         this.instanceManager.setSignerType(SignerType.EMBEDDED);
     }
-    newEmbeddedSigner(chainId, shieldAuthentication) {
-        if (!this.credentialsProvided()) {
-            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 ? Number(this.instanceManager.getChainID()) ?? null : chainId,
-            recovery: shieldAuthentication ?? null,
-        };
-        return new EmbeddedSigner(this.iframeManager, this.instanceManager, iframeConfiguration);
-    }
-    async loginWithEmailPassword({ email, password, }) {
-        this.instanceManager.removeAccessToken();
-        this.instanceManager.removeRefreshToken();
-        this.instanceManager.removePlayerID();
+    /**
+     * 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.logout();
         const result = await this.authManager.loginEmailPassword(email, password);
         this.storeCredentials({
             player: result.player.id,
@@ -5993,10 +6036,16 @@ class Openfort {
         });
         return result;
     }
-    async signUpWithEmailPassword({ email, password, options, }) {
-        this.instanceManager.removeAccessToken();
-        this.instanceManager.removeRefreshToken();
-        this.instanceManager.removePlayerID();
+    /**
+     * 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.logout();
         const result = await this.authManager.signupEmailPassword(email, password, options?.data.name);
         this.storeCredentials({
             player: result.player.id,
@@ -6005,31 +6054,117 @@ class Openfort {
         });
         return result;
     }
+    /**
+     * 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);
     }
+    /**
+     * 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);
     }
+    /**
+     * 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);
     }
+    /**
+     * Verifies the user's email.
+     *
+     * @param email - User's email.
+     * @param state - Verification state.
+     */
     async verifyEmail({ email, state }) {
         await this.authManager.verifyEmail(email, state);
     }
+    /**
+     * Initializes an OAuth authentication process.
+     *
+     * @param provider - OAuth provider.
+     * @param options - Additional options for initialization.
+     * @returns An InitAuthResponse object.
+     */
     async initOAuth({ provider, options }) {
+        this.logout();
         const authResponse = await this.authManager.initOAuth(provider, options);
         return authResponse;
     }
-    async initLinkOAuth({ provider, playerToken, options }) {
-        return await this.authManager.linkOAuth(provider, playerToken, options);
+    /**
+     * 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);
+    }
+    /**
+     * 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;
     }
+    /**
+     * Polls for OAuth authentication completion.
+     *
+     * @param key - OAuth polling key.
+     * @returns An AuthResponse object.
+     */
     async poolOAuth(key) {
         return await this.authManager.poolOAuth(key);
     }
-    async initSIWE({ address }) {
-        return await this.authManager.initSIWE(address);
-    }
+    /**
+     * 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({
@@ -6043,6 +6178,24 @@ class Openfort {
         }
         return result;
     }
+    /**
+     * 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();
@@ -6055,6 +6208,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,
@@ -6062,9 +6245,20 @@ class Openfort {
             thirdPartyTokenType: null,
         });
         this.instanceManager.setRefreshToken(auth.refreshToken);
-        this.instanceManager.setPlayerID(auth.player);
+        if (auth.player)
+            this.instanceManager.setPlayerID(auth.player);
     }
-    async sendSignatureTransactionIntentRequest(transactionIntentId, userOperationHash = null, signature = null) {
+    /**
+     * Sends a signature transaction intent request.
+     *
+     * @param transactionIntentId - Transaction intent ID.
+     * @param userOperationHash - User operation hash.
+     * @param signature - Transaction signature.
+     * @param optimistic - Whether the request is optimistic.
+     * @returns A TransactionIntentResponse object.
+     * @throws {OpenfortError} If no userOperationHash or signature is provided.
+     */
+    async sendSignatureTransactionIntentRequest(transactionIntentId, userOperationHash = null, signature = null, optimistic = false) {
         let newSignature = signature;
         if (!newSignature) {
             if (!userOperationHash) {
@@ -6083,11 +6277,20 @@ class Openfort {
             id: transactionIntentId,
             signatureRequest: {
                 signature: newSignature,
+                optimistic,
             },
         };
         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) {
@@ -6099,6 +6302,15 @@ 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) {
@@ -6132,14 +6344,15 @@ 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.
+     */
     async sendRegisterSessionRequest(sessionId, signature, optimistic) {
-        await this.recoverSigner();
-        if (!this.signer) {
-            throw new OpenfortError('No signer configured nor signature provided', OpenfortErrorType.MISSING_SIGNER_ERROR);
-        }
-        if (this.signer.getSingerType() !== SignerType.SESSION) {
-            throw new OpenfortError('Session signer must be configured to sign a session', OpenfortErrorType.MISSING_SESSION_SIGNER_ERROR);
-        }
         const request = {
             id: sessionId,
             signatureRequest: {
@@ -6150,6 +6363,78 @@ 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() {
+        const authType = this.credentialsProvided();
+        if (!authType) {
+            throw new OpenfortError('Must be logged in to validate and refresh token', OpenfortErrorType.NOT_LOGGED_IN_ERROR);
+        }
+        if (authType === exports.AuthType.OPENFORT) {
+            const auth = await this.authManager.validateCredentials();
+            this.storeCredentials(auth);
+            if (this.signer && this.signer.useCredentials()) {
+                await this.signer.updateAuthentication();
+            }
+        }
+    }
+    credentialsProvided() {
+        const token = this.instanceManager.getAccessToken();
+        const refreshToken = this.instanceManager.getRefreshToken();
+        if (!token) {
+            return null;
+        }
+        if (token.token && token.thirdPartyProvider && token.thirdPartyTokenType) {
+            return exports.AuthType.THIRD_PARTY;
+        }
+        if (token.token && refreshToken) {
+            return exports.AuthType.OPENFORT;
+        }
+        return null;
+    }
     async recoverSigner() {
         if (this.signer) {
             return;
@@ -6183,69 +6468,66 @@ class Openfort {
         };
         await checkSignerType(0);
     }
-    getEmbeddedState() {
+    newEmbeddedSigner(chainId) {
         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)));
-    }
-    getAccessToken() {
-        return this.instanceManager.getAccessToken()?.token ?? null;
-    }
-    isLoaded() {
-        if (!this.instanceManager.getJWK()) {
-            return false;
+            throw new OpenfortError('Must be logged in to configure embedded signer', OpenfortErrorType.NOT_LOGGED_IN_ERROR);
         }
-        if (this.signer && this.signer.getSingerType() === SignerType.EMBEDDED) {
-            return this.signer.iFrameLoaded();
+        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);
         }
-        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);
+        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);
         }
-        return await this.authManager.getUser(accessToken.token);
+        const shieldAuth = {
+            auth: shieldAuthType,
+            token,
+        };
+        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: shieldAuth,
+        };
+        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;