@openfort/openfort-js 0.7.7 → 0.7.9

package/dist/index.js

@@ -10,60 +10,6 @@ import { secp256k1 } from '@noble/curves/secp256k1';
 import { SigningKey } from '@ethersproject/signing-key';
 import { computeAddress } from '@ethersproject/transactions';
 
-var EmbeddedState;
-(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";
-})(EmbeddedState || (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 = {}));
-var TokenType;
-(function (TokenType) {
-    TokenType["ID_TOKEN"] = "idToken";
-    TokenType["CUSTOM_TOKEN"] = "customToken";
-})(TokenType || (TokenType = {}));
-var ThirdPartyOAuthProvider;
-(function (ThirdPartyOAuthProvider) {
-    ThirdPartyOAuthProvider["ACCELBYTE"] = "accelbyte";
-    ThirdPartyOAuthProvider["FIREBASE"] = "firebase";
-    ThirdPartyOAuthProvider["LOOTLOCKER"] = "lootlocker";
-    ThirdPartyOAuthProvider["PLAYFAB"] = "playfab";
-    ThirdPartyOAuthProvider["SUPABASE"] = "supabase";
-    ThirdPartyOAuthProvider["CUSTOM"] = "custom";
-    ThirdPartyOAuthProvider["OIDC"] = "oidc";
-})(ThirdPartyOAuthProvider || (ThirdPartyOAuthProvider = {}));
-var BasicAuthProvider;
-(function (BasicAuthProvider) {
-    BasicAuthProvider["EMAIL"] = "email";
-    BasicAuthProvider["WALLET"] = "wallet";
-})(BasicAuthProvider || (BasicAuthProvider = {}));
-var OAuthProvider;
-(function (OAuthProvider) {
-    OAuthProvider["GOOGLE"] = "google";
-    OAuthProvider["TWITTER"] = "twitter";
-    OAuthProvider["FACEBOOK"] = "facebook";
-})(OAuthProvider || (OAuthProvider = {}));
-var CodeChallengeMethodEnum;
-(function (CodeChallengeMethodEnum) {
-    CodeChallengeMethodEnum["PLAIN"] = "plain";
-    CodeChallengeMethodEnum["S256"] = "S256";
-})(CodeChallengeMethodEnum || (CodeChallengeMethodEnum = {}));
-
 /* tslint:disable */
 /* eslint-disable */
 /**
@@ -3067,6 +3013,65 @@ const createConfig = ({ basePath, accessToken, }) => {
     return new Configuration(apiConfigOptions);
 };
 
+var EmbeddedState;
+(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";
+})(EmbeddedState || (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 = {}));
+var AuthType;
+(function (AuthType) {
+    AuthType["OPENFORT"] = "openfort";
+    AuthType["THIRD_PARTY"] = "thirdParty";
+})(AuthType || (AuthType = {}));
+var TokenType;
+(function (TokenType) {
+    TokenType["ID_TOKEN"] = "idToken";
+    TokenType["CUSTOM_TOKEN"] = "customToken";
+})(TokenType || (TokenType = {}));
+var ThirdPartyOAuthProvider;
+(function (ThirdPartyOAuthProvider) {
+    ThirdPartyOAuthProvider["ACCELBYTE"] = "accelbyte";
+    ThirdPartyOAuthProvider["FIREBASE"] = "firebase";
+    ThirdPartyOAuthProvider["LOOTLOCKER"] = "lootlocker";
+    ThirdPartyOAuthProvider["PLAYFAB"] = "playfab";
+    ThirdPartyOAuthProvider["SUPABASE"] = "supabase";
+    ThirdPartyOAuthProvider["CUSTOM"] = "custom";
+    ThirdPartyOAuthProvider["OIDC"] = "oidc";
+})(ThirdPartyOAuthProvider || (ThirdPartyOAuthProvider = {}));
+var BasicAuthProvider;
+(function (BasicAuthProvider) {
+    BasicAuthProvider["EMAIL"] = "email";
+    BasicAuthProvider["WALLET"] = "wallet";
+})(BasicAuthProvider || (BasicAuthProvider = {}));
+var OAuthProvider;
+(function (OAuthProvider) {
+    OAuthProvider["GOOGLE"] = "google";
+    OAuthProvider["TWITTER"] = "twitter";
+    OAuthProvider["FACEBOOK"] = "facebook";
+})(OAuthProvider || (OAuthProvider = {}));
+var CodeChallengeMethodEnum;
+(function (CodeChallengeMethodEnum) {
+    CodeChallengeMethodEnum["PLAIN"] = "plain";
+    CodeChallengeMethodEnum["S256"] = "S256";
+})(CodeChallengeMethodEnum || (CodeChallengeMethodEnum = {}));
+
 var OpenfortErrorType;
 (function (OpenfortErrorType) {
     OpenfortErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
@@ -4601,8 +4606,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: v4(),
 };
 function announceProvider(detail) {
@@ -4660,11 +4665,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);
@@ -4846,7 +4854,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 importJWK({
                 kty: jwk.kty,
@@ -5022,6 +5036,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 {
@@ -5031,6 +5047,7 @@ class InstanceManager {
     jwk = null;
     sessionKey = null;
     deviceID = null;
+    shieldAuthType = null;
     chainId = null;
     accountAddress = null;
     accountType = null;
@@ -5162,9 +5179,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,
@@ -5249,6 +5267,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 {
@@ -5594,11 +5640,11 @@ class UpdateAuthenticationRequest {
         this.recovery = recovery;
     }
 }
-var AuthType;
-(function (AuthType) {
-    AuthType["OPENFORT"] = "openfort";
-    AuthType["CUSTOM"] = "custom";
-})(AuthType || (AuthType = {}));
+var ShieldAuthType;
+(function (ShieldAuthType) {
+    ShieldAuthType["OPENFORT"] = "openfort";
+    ShieldAuthType["CUSTOM"] = "custom";
+})(ShieldAuthType || (ShieldAuthType = {}));
 
 class MissingRecoveryPasswordError extends Error {
     constructor() {
@@ -5849,6 +5895,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()) {
@@ -5876,11 +5925,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);
         }
@@ -5901,33 +5957,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();
@@ -5938,30 +5976,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 === 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,
@@ -5970,10 +6013,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,
@@ -5982,31 +6031,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({
@@ -6020,6 +6155,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();
@@ -6032,6 +6185,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,
@@ -6039,9 +6222,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) {
@@ -6060,11 +6254,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) {
@@ -6076,6 +6279,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) {
@@ -6109,14 +6321,15 @@ class Openfort {
         }
         return await this.signer.sign(hash, 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: {
@@ -6127,6 +6340,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 EmbeddedState.UNAUTHENTICATED;
+        }
+        if (this.instanceManager.getSignerType() !== SignerType.EMBEDDED) {
+            return EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED;
+        }
+        if (!this.signer) {
+            this.signer = this.newEmbeddedSigner();
+        }
+        if (!this.instanceManager.getDeviceID()) {
+            return EmbeddedState.CREATING_ACCOUNT;
+        }
+        return 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 === 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 AuthType.THIRD_PARTY;
+        }
+        if (token.token && refreshToken) {
+            return AuthType.OPENFORT;
+        }
+        return null;
+    }
     async recoverSigner() {
         if (this.signer) {
             return;
@@ -6160,66 +6445,62 @@ class Openfort {
         };
         await checkSignerType(0);
     }
-    getEmbeddedState() {
+    newEmbeddedSigner(chainId) {
         if (!this.credentialsProvided()) {
-            return EmbeddedState.UNAUTHENTICATED;
-        }
-        if (this.instanceManager.getSignerType() !== SignerType.EMBEDDED) {
-            return EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED;
-        }
-        if (!this.signer) {
-            this.signer = this.newEmbeddedSigner();
-        }
-        if (!this.instanceManager.getDeviceID()) {
-            return EmbeddedState.CREATING_ACCOUNT;
-        }
-        return 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(ShieldAuthType.OPENFORT);
+            shieldAuthType = 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 === 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();
     }
 }
 
-export { AuthType, BasicAuthProvider, EmbeddedState, OAuthProvider, OpenfortConfiguration, SDKConfiguration, ShieldConfiguration, ThirdPartyOAuthProvider, TokenType, Openfort as default };
+export { AuthType, BasicAuthProvider, EmbeddedState, OAuthProvider, OpenfortConfiguration, OpenfortError, SDKConfiguration, ShieldAuthType, ShieldConfiguration, ThirdPartyOAuthProvider, TokenType, Openfort as default };