@injectivelabs/wallet-turnkey 1.16.6-alpha.0 → 1.16.6

package/dist/cjs/strategy/turnkey/turnkey.js

@@ -15,66 +15,76 @@ const utils_js_1 = require("../../utils.js");
 class TurnkeyWallet {
     otpId;
     turnkey;
-    userOrganizationId;
+    organizationId;
     client;
     metadata;
-    indexedDbClient;
+    iframeClient;
     accountMap = {};
     setMetadata(metadata) {
         this.metadata = { ...this.metadata, ...metadata };
     }
     constructor(metadata) {
         this.metadata = metadata;
+        this.organizationId = metadata.organizationId;
         this.client = new utils_1.HttpRestClient(metadata.apiServerEndpoint);
     }
     static async getTurnkeyInstance(metadata) {
-        const { turnkey, indexedDbClient } = await createTurnkeyClient(metadata);
+        const { turnkey, iframeClient } = await createTurnkeyIFrame(metadata);
         return {
             turnkey,
-            indexedDbClient,
+            iframeClient,
         };
     }
     async getTurnkey() {
-        if (!this.indexedDbClient) {
-            await this.initClient();
+        if (!this.iframeClient) {
+            await this.initFrame();
         }
         if (!this.turnkey) {
             this.turnkey = new sdk_browser_1.Turnkey(this.metadata);
         }
         return this.turnkey;
     }
-    async getIndexedDbClient() {
-        if (!this.indexedDbClient) {
-            await this.initClient();
+    async getIframeClient() {
+        if (!this.iframeClient) {
+            await this.initFrame();
         }
-        if (!this.indexedDbClient) {
-            throw new exceptions_1.WalletException(new Error('Indexed DB client not initialized'));
+        if (!this.iframeClient) {
+            throw new exceptions_1.WalletException(new Error('Iframe client not initialized'));
         }
-        return this.indexedDbClient;
+        return this.iframeClient;
     }
     async getSession(existingCredentialBundle) {
+        const { metadata } = this;
+        const iframeClient = await this.getIframeClient();
+        const turnkey = await this.getTurnkey();
+        const currentSession = await turnkey.getSession();
+        const organizationId = currentSession?.organizationId || metadata.defaultOrganizationId;
+        const credentialBundle = existingCredentialBundle || currentSession?.token;
+        if (!credentialBundle) {
+            return {
+                session: undefined,
+                organizationId,
+            };
+        }
         try {
-            const { metadata } = this;
-            const indexedDbClient = await this.getIndexedDbClient();
-            const turnkey = await this.getTurnkey();
-            const session = await turnkey.getSession();
-            const organizationId = session?.organizationId || metadata.defaultOrganizationId;
-            const credentialBundle = existingCredentialBundle || session?.token;
-            if (!credentialBundle) {
-                return {
-                    session: undefined,
-                    organizationId,
-                };
-            }
-            const user = await indexedDbClient.getWhoami();
+            const loginResult = await iframeClient.injectCredentialBundle(credentialBundle);
+            // If there is no session, we want to force a refresh to enable to browser SDK to handle key storage and proper session management.
+            await iframeClient.refreshSession({
+                sessionType: sdk_browser_1.SessionType.READ_WRITE,
+                targetPublicKey: iframeClient.iframePublicKey,
+                expirationSeconds: this.metadata.expirationSeconds,
+            });
+            const [session, user] = await Promise.all([
+                turnkey.getSession(),
+                iframeClient.getWhoami(),
+            ]);
             const actualOrganizationId = user?.organizationId || session?.organizationId || organizationId;
-            if (!user) {
+            if (!loginResult) {
                 return {
                     session: undefined,
                     organizationId: actualOrganizationId,
                 };
             }
-            this.userOrganizationId = actualOrganizationId;
             return {
                 session,
                 organizationId: actualOrganizationId,
@@ -85,17 +95,17 @@ class TurnkeyWallet {
         }
     }
     async getAccounts() {
-        const indexedDbClient = await this.getIndexedDbClient();
-        if (!this.userOrganizationId) {
+        const iframeClient = await this.getIframeClient();
+        if (!this.organizationId) {
             return [];
         }
         try {
-            const response = await indexedDbClient.getWallets({
-                organizationId: this.userOrganizationId,
+            const response = await iframeClient.getWallets({
+                organizationId: this.organizationId,
             });
-            const accounts = await Promise.allSettled(response.wallets.map((wallet) => indexedDbClient.getWalletAccounts({
+            const accounts = await Promise.allSettled(response.wallets.map((wallet) => iframeClient.getWalletAccounts({
                 walletId: wallet.walletId,
-                organizationId: this.userOrganizationId,
+                organizationId: this.organizationId,
             })));
             const filteredAccounts = accounts
                 .filter((account) => account.status === 'fulfilled')
@@ -121,33 +131,61 @@ class TurnkeyWallet {
             });
         }
     }
-    async getOrCreateAndGetAccount(address) {
+    async getOrCreateAndGetAccount(address, organizationId) {
         const { accountMap } = this;
-        const indexedDbClient = await this.getIndexedDbClient();
-        const organizationId = this.userOrganizationId;
+        const iframeClient = await this.getIframeClient();
         if (accountMap[address] || accountMap[address.toLowerCase()]) {
             return accountMap[address] || accountMap[address.toLowerCase()];
         }
         if (!organizationId) {
             throw new exceptions_1.WalletException(new Error('Organization ID is required'));
         }
-        indexedDbClient.config.organizationId = organizationId;
+        iframeClient.config.organizationId = organizationId;
         if (!address) {
             throw new exceptions_1.WalletException(new Error('Account address not found'));
         }
         const turnkeyAccount = await (0, viem_1.createAccount)({
             organizationId,
             signWith: address,
-            client: indexedDbClient,
+            client: iframeClient,
         });
         this.accountMap[address] = turnkeyAccount;
         return turnkeyAccount;
     }
+    async injectAndRefresh(credentialBundle, options) {
+        const expirationSeconds = options.expirationSeconds || consts_js_1.DEFAULT_TURNKEY_REFRESH_SECONDS;
+        const iframeClient = await this.getIframeClient();
+        await iframeClient.injectCredentialBundle(credentialBundle);
+        await iframeClient.loginWithBundle({
+            bundle: credentialBundle,
+            expirationSeconds,
+        });
+        await iframeClient.refreshSession({
+            sessionType: sdk_browser_1.SessionType.READ_WRITE,
+            targetPublicKey: iframeClient.iframePublicKey,
+            expirationSeconds,
+        });
+        const session = await this.turnkey?.getSession();
+        if (!session) {
+            throw new exceptions_1.TurnkeyWalletSessionException(new Error('Session expired. Please login again.'));
+        }
+        this.organizationId = session.organizationId;
+        this.metadata.organizationId = session.organizationId;
+        // Refresh the session 2 minutes before it expires
+        setTimeout(() => {
+            iframeClient.refreshSession({
+                expirationSeconds: session?.expiry,
+                sessionType: sdk_browser_1.SessionType.READ_WRITE,
+                targetPublicKey: iframeClient.iframePublicKey,
+            });
+        }, (parseInt(expirationSeconds) - 120) * 1000);
+        return;
+    }
     async initOTP(email) {
-        const indexedDbClient = await this.getIndexedDbClient();
+        const iframeClient = await this.getIframeClient();
         const result = await otp_js_1.TurnkeyOtpWallet.initEmailOTP({
             client: this.client,
-            indexedDbClient,
+            iframeClient,
             email,
             otpInitPath: this.metadata.otpInitPath || consts_js_1.TURNKEY_OTP_INIT_PATH,
         });
@@ -155,7 +193,7 @@ class TurnkeyWallet {
             throw new exceptions_1.WalletException(new Error('Failed to initialize OTP'));
         }
         if (result?.organizationId) {
-            this.userOrganizationId = result.organizationId;
+            this.organizationId = result.organizationId;
         }
         if (result?.otpId) {
             this.otpId = result.otpId;
@@ -163,35 +201,30 @@ class TurnkeyWallet {
         return result;
     }
     async confirmOTP(otpCode) {
-        const indexedDbClient = await this.getIndexedDbClient();
-        const targetPublicKey = await indexedDbClient.getPublicKey();
+        const iframeClient = await this.getIframeClient();
         if (!this.otpId) {
             throw new exceptions_1.WalletException(new Error('OTP ID is required'));
         }
-        if (!targetPublicKey) {
-            throw new exceptions_1.WalletException(new Error('Target public key not found'));
-        }
-        if (!this.userOrganizationId) {
-            throw new exceptions_1.WalletException(new Error('Organization ID is required'));
-        }
         const result = await otp_js_1.TurnkeyOtpWallet.confirmEmailOTP({
             otpCode,
+            iframeClient,
             client: this.client,
             emailOTPId: this.otpId,
-            organizationId: this.userOrganizationId,
-            targetPublicKey,
+            organizationId: this.organizationId,
             otpVerifyPath: this.metadata.otpVerifyPath || consts_js_1.TURNKEY_OTP_VERIFY_PATH,
         });
-        if (!result || !result.session) {
+        if (!result || !result.credentialBundle) {
             throw new exceptions_1.WalletException(new Error('Failed to confirm OTP'));
         }
-        await indexedDbClient.loginWithSession(result.session);
-        this.userOrganizationId = result.organizationId;
+        await this.injectAndRefresh(result.credentialBundle, {
+            organizationId: result.organizationId,
+            expirationSeconds: this.metadata.expirationSeconds,
+        });
         return result;
     }
     async initOAuth(provider) {
-        const indexedDbClient = await this.getIndexedDbClient();
-        const nonce = await oauth_js_1.TurnkeyOauthWallet.generateOAuthNonce(indexedDbClient);
+        const iframeClient = await this.getIframeClient();
+        const nonce = await oauth_js_1.TurnkeyOauthWallet.generateOAuthNonce(iframeClient);
         if (provider === wallet_base_1.TurnkeyProvider.Apple) {
             // TODO: implement the ability to generate Apple OAuth URL
             return nonce;
@@ -206,10 +239,10 @@ class TurnkeyWallet {
         });
     }
     async confirmOAuth(provider, oidcToken) {
-        const indexedDbClient = await this.getIndexedDbClient();
+        const iframeClient = await this.getIframeClient();
         const oauthResult = await oauth_js_1.TurnkeyOauthWallet.oauthLogin({
             oidcToken,
-            indexedDbClient,
+            iframeClient,
             client: this.client,
             providerName: provider.toString(),
             oauthLoginPath: this.metadata.oauthLoginPath || consts_js_1.TURNKEY_OAUTH_PATH,
@@ -217,41 +250,54 @@ class TurnkeyWallet {
         if (!oauthResult || !oauthResult.credentialBundle) {
             throw new exceptions_1.WalletException(new Error('Unexpected OAuth result'));
         }
-        await indexedDbClient.loginWithSession(oauthResult.credentialBundle);
-        this.userOrganizationId = oauthResult.organizationId;
+        await this.injectAndRefresh(oauthResult.credentialBundle, {
+            organizationId: oauthResult.organizationId,
+            expirationSeconds: this.metadata.expirationSeconds,
+        });
         return oauthResult.credentialBundle;
     }
     async refreshSession() {
         const session = await this.getSession();
-        const indexedDbClient = await this.getIndexedDbClient();
         if (session.session?.token) {
-            await indexedDbClient.refreshSession({
-                sessionType: sdk_browser_1.SessionType.READ_WRITE,
-                expirationSeconds: this.metadata.expirationSeconds,
+            await this.injectAndRefresh(session.session.token, {
+                expirationSeconds: this.metadata.expirationSeconds || consts_js_1.DEFAULT_TURNKEY_REFRESH_SECONDS,
             });
-            this.userOrganizationId = session.organizationId;
             return session.session.token;
         }
         throw new exceptions_1.TurnkeyWalletSessionException(new Error('Session expired. Please login again.'));
     }
-    async initClient() {
+    async initFrame() {
         const { metadata } = this;
-        const { turnkey, indexedDbClient } = await createTurnkeyClient(metadata);
+        const { turnkey, iframeClient } = await createTurnkeyIFrame(metadata);
         this.turnkey = turnkey;
-        this.indexedDbClient = indexedDbClient;
-        return { turnkey, indexedDbClient };
+        this.iframeClient = iframeClient;
     }
 }
 exports.TurnkeyWallet = TurnkeyWallet;
-async function createTurnkeyClient(metadata) {
+async function createTurnkeyIFrame(metadata) {
     const turnkey = new sdk_browser_1.Turnkey(metadata);
-    const indexedDbClient = await turnkey.indexedDbClient();
-    await indexedDbClient.init();
+    const turnkeyAuthIframeElementId = metadata.iframeElementId || 'turnkey-auth-iframe-element-id';
+    if (!metadata.iframeContainerId) {
+        throw new exceptions_1.GeneralException(new Error('iframeContainerId is required'));
+    }
     if (!turnkey) {
         throw new exceptions_1.GeneralException(new Error('Turnkey is not initialized'));
     }
+    const iframe = document.getElementById(metadata.iframeContainerId);
+    if (!iframe) {
+        throw new exceptions_1.GeneralException(new Error('iframe is null'));
+    }
+    const existingIframeClient = document.getElementById(turnkeyAuthIframeElementId);
+    if (existingIframeClient) {
+        existingIframeClient.remove();
+    }
+    const iframeClient = await turnkey.iframeClient({
+        iframeContainer: iframe,
+        iframeElementId: turnkeyAuthIframeElementId,
+        iframeUrl: metadata?.iframeUrl || 'https://auth.turnkey.com',
+    });
     return {
         turnkey,
-        indexedDbClient,
+        iframeClient,
     };
 }

package/dist/cjs/strategy/types.d.ts

@@ -17,7 +17,7 @@ export type TurnkeyOTPCredentialsResponse = {
     organizationId: string;
 };
 export type TurnkeyConfirmEmailOTPResponse = {
-    session: string;
+    credentialBundle: string;
     organizationId: string;
 };
 export type TurnkeyOauthLoginResponse = {

package/dist/esm/strategy/strategy.d.ts

@@ -1,14 +1,14 @@
 import { TxRaw, AminoSignResponse, DirectSignResponse } from '@injectivelabs/sdk-ts';
-import { StdSignDoc, WalletDeviceType, type WalletMetadata, BaseConcreteStrategy, ConcreteWalletStrategy, SendTransactionOptions, WalletStrategyEvmOptions, ConcreteEvmWalletStrategyArgs } from '@injectivelabs/wallet-base';
 import { HttpRestClient } from '@injectivelabs/utils';
-import { TurnkeyIndexedDbClient } from '@turnkey/sdk-browser';
-import { AccountAddress, EvmChainId } from '@injectivelabs/ts-types';
+import { AccountAddress, EthereumChainId } from '@injectivelabs/ts-types';
+import { TurnkeyIframeClient } from '@turnkey/sdk-browser';
+import { StdSignDoc, WalletDeviceType, type WalletMetadata, BaseConcreteStrategy, ConcreteWalletStrategy, SendTransactionOptions, WalletStrategyEthereumOptions, ConcreteEthereumWalletStrategyArgs } from '@injectivelabs/wallet-base';
 import { TurnkeyWallet } from './turnkey/turnkey.js';
 export declare class TurnkeyWalletStrategy extends BaseConcreteStrategy implements ConcreteWalletStrategy {
     turnkeyWallet?: TurnkeyWallet;
-    evmOptions: WalletStrategyEvmOptions;
+    ethereumOptions: WalletStrategyEthereumOptions;
     client: HttpRestClient;
-    constructor(args: ConcreteEvmWalletStrategyArgs & {
+    constructor(args: ConcreteEthereumWalletStrategyArgs & {
         apiServerEndpoint?: string;
     });
     getWalletDeviceType(): Promise<WalletDeviceType>;
@@ -22,7 +22,7 @@ export declare class TurnkeyWalletStrategy extends BaseConcreteStrategy implemen
     getWalletClient<TurnkeyWallet>(): Promise<TurnkeyWallet>;
     sendEvmTransaction(transaction: unknown, args: {
         address: AccountAddress;
-        evmChainId: EvmChainId;
+        ethereumChainId: EthereumChainId;
     }): Promise<string>;
     sendTransaction(transaction: TxRaw, options: SendTransactionOptions): Promise<any>;
     signEip712TypedData(eip712json: string, address: AccountAddress): Promise<string>;
@@ -38,8 +38,9 @@ export declare class TurnkeyWalletStrategy extends BaseConcreteStrategy implemen
     }): Promise<AminoSignResponse>;
     signArbitrary(_signer: AccountAddress, _data: string | Uint8Array): Promise<string>;
     getEthereumChainId(): Promise<string>;
-    getEvmTransactionReceipt(txHash: string, evmChainId?: EvmChainId): Promise<Record<string, any>>;
+    getEvmTransactionReceipt(txHash: string, ethereumChainId?: EthereumChainId): Promise<Record<string, any>>;
     getPubKey(): Promise<string>;
-    getIndexedDbClient(): Promise<TurnkeyIndexedDbClient>;
+    getIframeClient(): Promise<TurnkeyIframeClient>;
     private getTurnkeyWallet;
+    private getOrganizationId;
 }

package/dist/esm/strategy/strategy.js

@@ -1,15 +1,16 @@
 /* eslint-disable class-methods-use-this */
 import { TxGrpcApi, } from '@injectivelabs/sdk-ts';
 import { ErrorType, WalletException, UnspecifiedErrorCode, TransactionException, CosmosWalletException, } from '@injectivelabs/exceptions';
-import { http, getAddress, createPublicClient, createWalletClient, } from 'viem';
-import { WalletAction, WalletDeviceType, BaseConcreteStrategy, } from '@injectivelabs/wallet-base';
+import { getAddress } from 'viem';
 import { sleep, HttpRestClient } from '@injectivelabs/utils';
+import { http, createPublicClient, createWalletClient, } from 'viem';
+import { WalletAction, WalletDeviceType, BaseConcreteStrategy, } from '@injectivelabs/wallet-base';
 import { TurnkeyErrorCodes } from './types.js';
 import { TurnkeyWallet } from './turnkey/turnkey.js';
 import { DEFAULT_EVM_CHAIN_CONFIG } from './consts.js';
 export class TurnkeyWalletStrategy extends BaseConcreteStrategy {
     turnkeyWallet;
-    evmOptions;
+    ethereumOptions;
     client;
     constructor(args) {
         super(args);
@@ -18,7 +19,7 @@ export class TurnkeyWalletStrategy extends BaseConcreteStrategy {
             throw new WalletException(new Error('apiServerEndpoint is required'));
         }
         this.client = new HttpRestClient(endpoint);
-        this.evmOptions = args.evmOptions;
+        this.ethereumOptions = args.ethereumOptions;
     }
     async getWalletDeviceType() {
         return Promise.resolve(WalletDeviceType.Browser);
@@ -46,7 +47,7 @@ export class TurnkeyWalletStrategy extends BaseConcreteStrategy {
                 }
                 return true;
             }
-            return !!(await turnkeyWallet.getIndexedDbClient());
+            return !!(await turnkeyWallet.getIframeClient());
         }
         catch (e) {
             return false;
@@ -55,15 +56,15 @@ export class TurnkeyWalletStrategy extends BaseConcreteStrategy {
     async disconnect() {
         const turnkeyWallet = await this.getTurnkeyWallet();
         const turnkey = await turnkeyWallet.getTurnkey();
-        const indexedDbClient = await turnkeyWallet.getIndexedDbClient();
         const isUserLoggedIn = await turnkey.getSession();
         if (!isUserLoggedIn) {
             return;
         }
-        await Promise.allSettled([turnkey.logout(), indexedDbClient.clear()]);
+        await turnkey.logout();
     }
     async getAddresses() {
         const turnkeyWallet = await this.getTurnkeyWallet();
+        await turnkeyWallet.getSession();
         try {
             return await turnkeyWallet.getAccounts();
         }
@@ -88,17 +89,18 @@ export class TurnkeyWalletStrategy extends BaseConcreteStrategy {
     }
     async sendEvmTransaction(transaction, args) {
         try {
-            const options = this.evmOptions;
+            const options = this.ethereumOptions;
             const turnkeyWallet = await this.getTurnkeyWallet();
-            const chainId = args.evmChainId || options.evmChainId;
-            const url = options.rpcUrl || options.rpcUrls?.[args.evmChainId];
+            const organizationId = await this.getOrganizationId();
+            const chainId = args.ethereumChainId || options.ethereumChainId;
+            const url = options.rpcUrl || options.rpcUrls?.[args.ethereumChainId];
             if (!url) {
-                throw new WalletException(new Error('Please pass rpcUrl within the evmOptions'), {
+                throw new WalletException(new Error('Please pass rpcUrl within the ethereumOptions'), {
                     code: UnspecifiedErrorCode,
                     context: WalletAction.SendEvmTransaction,
                 });
             }
-            const account = await turnkeyWallet.getOrCreateAndGetAccount(getAddress(args.address));
+            const account = await turnkeyWallet.getOrCreateAndGetAccount(getAddress(args.address), organizationId);
             const accountClient = createWalletClient({
                 account: account,
                 chain: {
@@ -145,9 +147,10 @@ export class TurnkeyWalletStrategy extends BaseConcreteStrategy {
     }
     async signEip712TypedData(eip712json, address) {
         const turnkeyWallet = await this.getTurnkeyWallet();
+        const organizationId = await this.getOrganizationId();
         //? Turnkey expects the case sensitive address and the current impl of getChecksumAddress from sdk-ts doesn't play nice with browser envs
         const checksumAddress = getAddress(address);
-        const account = await turnkeyWallet.getOrCreateAndGetAccount(checksumAddress);
+        const account = await turnkeyWallet.getOrCreateAndGetAccount(checksumAddress, organizationId);
         if (!account) {
             throw new WalletException(new Error('Turnkey account not found'));
         }
@@ -193,14 +196,14 @@ export class TurnkeyWalletStrategy extends BaseConcreteStrategy {
             context: WalletAction.GetChainId,
         });
     }
-    async getEvmTransactionReceipt(txHash, evmChainId) {
-        const options = this.evmOptions;
+    async getEvmTransactionReceipt(txHash, ethereumChainId) {
+        const options = this.ethereumOptions;
         const maxAttempts = 10;
         const interval = 3000;
-        const chainId = evmChainId || options.evmChainId;
+        const chainId = ethereumChainId || options.ethereumChainId;
         const url = options.rpcUrl || options.rpcUrls?.[chainId];
         if (!url) {
-            throw new WalletException(new Error('Please pass rpcUrl within the evmOptions'), {
+            throw new WalletException(new Error('Please pass rpcUrl within the ethereumOptions'), {
                 code: UnspecifiedErrorCode,
                 context: WalletAction.GetEvmTransactionReceipt,
             });
@@ -237,10 +240,9 @@ export class TurnkeyWalletStrategy extends BaseConcreteStrategy {
     async getPubKey() {
         throw new WalletException(new Error('You can only fetch PubKey from Cosmos native wallets'));
     }
-    async getIndexedDbClient() {
+    async getIframeClient() {
         const turnkeyWallet = await this.getTurnkeyWallet();
-        const indexedDbClient = await turnkeyWallet.getIndexedDbClient();
-        return indexedDbClient;
+        return turnkeyWallet.getIframeClient();
     }
     async getTurnkeyWallet() {
         const { metadata } = this;
@@ -254,8 +256,20 @@ export class TurnkeyWalletStrategy extends BaseConcreteStrategy {
             if (!metadata.turnkey.apiServerEndpoint) {
                 throw new WalletException(new Error('Turnkey apiServerEndpoint is required'));
             }
+            if (!metadata.turnkey.defaultOrganizationId) {
+                throw new WalletException(new Error('Turnkey defaultOrganizationId is required'));
+            }
             this.turnkeyWallet = new TurnkeyWallet(metadata.turnkey);
         }
         return this.turnkeyWallet;
     }
+    async getOrganizationId() {
+        const { metadata } = this;
+        const organizationId = metadata?.turnkey?.organizationId ||
+            metadata?.turnkey?.defaultOrganizationId;
+        if (!organizationId) {
+            throw new WalletException(new Error('Organization ID is required'));
+        }
+        return organizationId;
+    }
 }

package/dist/esm/strategy/turnkey/oauth.d.ts

@@ -1,13 +1,13 @@
-import type { TurnkeyIndexedDbClient } from '@turnkey/sdk-browser';
+import type { TurnkeyIframeClient } from '@turnkey/sdk-browser';
 import { type HttpRestClient } from '@injectivelabs/utils';
 export declare class TurnkeyOauthWallet {
-    static generateOAuthNonce(indexedDbClient: TurnkeyIndexedDbClient): Promise<string>;
+    static generateOAuthNonce(iframeClient: TurnkeyIframeClient): Promise<string>;
     static oauthLogin(args: {
         oidcToken: string;
         client: HttpRestClient;
         oauthLoginPath?: string;
         providerName: 'google' | 'apple';
-        indexedDbClient: TurnkeyIndexedDbClient;
+        iframeClient: TurnkeyIframeClient;
         expirationSeconds?: number;
     }): Promise<{
         organizationId: string;

package/dist/esm/strategy/turnkey/oauth.js

@@ -2,10 +2,9 @@ import { ErrorType, WalletException, UnspecifiedErrorCode, } from '@injectivelab
 import { sha256 } from '@injectivelabs/sdk-ts';
 import { DEFAULT_TURNKEY_REFRESH_SECONDS, TURNKEY_OAUTH_PATH, } from '../consts.js';
 export class TurnkeyOauthWallet {
-    static async generateOAuthNonce(indexedDbClient) {
+    static async generateOAuthNonce(iframeClient) {
         try {
-            await indexedDbClient.resetKeyPair();
-            const targetPublicKey = await indexedDbClient.getPublicKey();
+            const targetPublicKey = iframeClient.iframePublicKey;
             if (!targetPublicKey) {
                 throw new WalletException(new Error('Target public key not found'));
             }
@@ -22,10 +21,10 @@ export class TurnkeyOauthWallet {
         }
     }
     static async oauthLogin(args) {
-        const { client, indexedDbClient, expirationSeconds } = args;
+        const { client, iframeClient, expirationSeconds } = args;
         const path = args.oauthLoginPath || TURNKEY_OAUTH_PATH;
         try {
-            const targetPublicKey = await indexedDbClient.getPublicKey();
+            const targetPublicKey = iframeClient.iframePublicKey;
             if (!targetPublicKey) {
                 throw new WalletException(new Error('Target public key not found'));
             }

package/dist/esm/strategy/turnkey/otp.d.ts

@@ -1,4 +1,4 @@
-import { TurnkeyIndexedDbClient } from '@turnkey/sdk-browser';
+import { type TurnkeyIframeClient } from '@turnkey/sdk-browser';
 import { type TurnkeyConfirmEmailOTPResponse, type TurnkeyOTPCredentialsResponse } from './../types.js';
 import { type HttpRestClient } from '@injectivelabs/utils';
 export declare class TurnkeyOtpWallet {
@@ -7,16 +7,15 @@ export declare class TurnkeyOtpWallet {
         subOrgId?: string;
         otpInitPath?: string;
         client: HttpRestClient;
-        indexedDbClient: TurnkeyIndexedDbClient;
+        iframeClient: TurnkeyIframeClient;
         invalidateExistingSessions?: boolean;
-        expirationSeconds?: number;
     }): Promise<TurnkeyOTPCredentialsResponse | undefined>;
     static confirmEmailOTP(args: {
         otpCode: string;
         emailOTPId: string;
         client: HttpRestClient;
-        targetPublicKey: string;
         organizationId: string;
+        iframeClient: TurnkeyIframeClient;
         otpVerifyPath?: string;
         expirationSeconds?: number;
     }): Promise<TurnkeyConfirmEmailOTPResponse | undefined>;

package/dist/esm/strategy/turnkey/otp.js

@@ -2,21 +2,18 @@ import { ErrorType, WalletException, UnspecifiedErrorCode, } from '@injectivelab
 import { DEFAULT_TURNKEY_REFRESH_SECONDS, TURNKEY_OTP_INIT_PATH, TURNKEY_OTP_VERIFY_PATH, } from '../consts.js';
 export class TurnkeyOtpWallet {
     static async initEmailOTP(args) {
-        const { client, indexedDbClient, expirationSeconds } = args;
+        const { client, iframeClient } = args;
         try {
-            await indexedDbClient.resetKeyPair();
-            let publicKey = await indexedDbClient.getPublicKey();
-            if (!publicKey) {
-                throw new WalletException(new Error('Public key not found'));
+            const targetPublicKey = iframeClient.iframePublicKey;
+            if (!targetPublicKey) {
+                throw new WalletException(new Error('Target public key not found'));
             }
             // client.$post is undefined, resorting to this for now
             const response = await client.post(args.otpInitPath || TURNKEY_OTP_INIT_PATH, {
-                targetPublicKey: publicKey,
+                targetPublicKey,
                 email: args.email,
                 suborgId: args.subOrgId,
                 invalidateExistingSessions: args.invalidateExistingSessions,
-                isUsingIndexedDB: true,
-                expirationSeconds: expirationSeconds || DEFAULT_TURNKEY_REFRESH_SECONDS,
             });
             return response?.data;
         }
@@ -29,11 +26,15 @@ export class TurnkeyOtpWallet {
         }
     }
     static async confirmEmailOTP(args) {
-        const { client, expirationSeconds, targetPublicKey } = args;
+        const { client, iframeClient, expirationSeconds } = args;
         try {
             const organizationId = args.organizationId;
             const emailOTPId = args.emailOTPId;
+            const targetPublicKey = iframeClient.iframePublicKey;
             const otpVerifyPath = args.otpVerifyPath || TURNKEY_OTP_VERIFY_PATH;
+            if (!targetPublicKey) {
+                throw new WalletException(new Error('Target public key not found'));
+            }
             if (!emailOTPId) {
                 throw new WalletException(new Error('Email OTP ID is required'));
             }
@@ -41,7 +42,6 @@ export class TurnkeyOtpWallet {
                 throw new WalletException(new Error('Organization ID is required'));
             }
             const response = await client.post(otpVerifyPath, {
-                isUsingIndexedDB: true,
                 targetPublicKey,
                 otpId: emailOTPId,
                 otpCode: args.otpCode,