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

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

@@ -1,33 +1,37 @@
 import { TurnkeyMetadata, TurnkeyProvider } from '@injectivelabs/wallet-base';
 import { createAccount } from '@turnkey/viem';
 import { HttpRestClient } from '@injectivelabs/utils';
-import { Turnkey, TurnkeyIndexedDbClient } from '@turnkey/sdk-browser';
+import { Turnkey, TurnkeyIframeClient } from '@turnkey/sdk-browser';
 export declare class TurnkeyWallet {
     private otpId?;
     protected turnkey?: Turnkey;
-    userOrganizationId?: string;
+    organizationId: string;
     protected client: HttpRestClient;
     private metadata;
-    protected indexedDbClient?: TurnkeyIndexedDbClient;
+    protected iframeClient?: TurnkeyIframeClient;
     private accountMap;
     setMetadata(metadata: Partial<TurnkeyMetadata>): void;
     constructor(metadata: TurnkeyMetadata);
     static getTurnkeyInstance(metadata: TurnkeyMetadata): Promise<{
         turnkey: Turnkey;
-        indexedDbClient: TurnkeyIndexedDbClient;
+        iframeClient: TurnkeyIframeClient;
     }>;
     getTurnkey(): Promise<Turnkey>;
-    getIndexedDbClient(): Promise<TurnkeyIndexedDbClient>;
+    getIframeClient(): Promise<TurnkeyIframeClient>;
     getSession(existingCredentialBundle?: string): Promise<{
-        session: import("@turnkey/sdk-browser").Session | undefined;
+        session: import("@turnkey/sdk-types").Session | undefined;
         organizationId: string;
     }>;
     getAccounts(): Promise<string[]>;
-    getOrCreateAndGetAccount(address: string): Promise<ReturnType<typeof createAccount>>;
+    getOrCreateAndGetAccount(address: string, organizationId: string): Promise<ReturnType<typeof createAccount>>;
+    injectAndRefresh(credentialBundle: string, options: {
+        expirationSeconds?: string;
+        organizationId?: string;
+    }): Promise<void>;
     initOTP(email: string): Promise<import("../types.js").TurnkeyOTPCredentialsResponse>;
     confirmOTP(otpCode: string): Promise<import("../types.js").TurnkeyConfirmEmailOTPResponse>;
     initOAuth(provider: TurnkeyProvider.Google | TurnkeyProvider.Apple): Promise<string>;
     confirmOAuth(provider: TurnkeyProvider.Google | TurnkeyProvider.Apple, oidcToken: string): Promise<string>;
     refreshSession(): Promise<string>;
-    private initClient;
+    private initFrame;
 }

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

@@ -3,8 +3,8 @@ import { WalletAction, TurnkeyProvider, } from '@injectivelabs/wallet-base';
 import { createAccount } from '@turnkey/viem';
 import { HttpRestClient } from '@injectivelabs/utils';
 import { getInjectiveAddress } from '@injectivelabs/sdk-ts';
-import { SessionType, Turnkey, } from '@turnkey/sdk-browser';
-import { TURNKEY_OAUTH_PATH, TURNKEY_OTP_INIT_PATH, TURNKEY_OTP_VERIFY_PATH, } from '../consts.js';
+import { SessionType, Turnkey } from '@turnkey/sdk-browser';
+import { TURNKEY_OAUTH_PATH, TURNKEY_OTP_INIT_PATH, TURNKEY_OTP_VERIFY_PATH, DEFAULT_TURNKEY_REFRESH_SECONDS, } from '../consts.js';
 import { TurnkeyOtpWallet } from './otp.js';
 import { TurnkeyErrorCodes } from '../types.js';
 import { TurnkeyOauthWallet } from './oauth.js';
@@ -12,66 +12,76 @@ import { generateGoogleUrl } from '../../utils.js';
 export 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 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 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 WalletException(new Error('Indexed DB client not initialized'));
+        if (!this.iframeClient) {
+            throw new 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: 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,
@@ -82,17 +92,17 @@ export 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')
@@ -118,33 +128,61 @@ export 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 WalletException(new Error('Organization ID is required'));
         }
-        indexedDbClient.config.organizationId = organizationId;
+        iframeClient.config.organizationId = organizationId;
         if (!address) {
             throw new WalletException(new Error('Account address not found'));
         }
         const turnkeyAccount = await createAccount({
             organizationId,
             signWith: address,
-            client: indexedDbClient,
+            client: iframeClient,
         });
         this.accountMap[address] = turnkeyAccount;
         return turnkeyAccount;
     }
+    async injectAndRefresh(credentialBundle, options) {
+        const expirationSeconds = options.expirationSeconds || DEFAULT_TURNKEY_REFRESH_SECONDS;
+        const iframeClient = await this.getIframeClient();
+        await iframeClient.injectCredentialBundle(credentialBundle);
+        await iframeClient.loginWithBundle({
+            bundle: credentialBundle,
+            expirationSeconds,
+        });
+        await iframeClient.refreshSession({
+            sessionType: SessionType.READ_WRITE,
+            targetPublicKey: iframeClient.iframePublicKey,
+            expirationSeconds,
+        });
+        const session = await this.turnkey?.getSession();
+        if (!session) {
+            throw new 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: 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 TurnkeyOtpWallet.initEmailOTP({
             client: this.client,
-            indexedDbClient,
+            iframeClient,
             email,
             otpInitPath: this.metadata.otpInitPath || TURNKEY_OTP_INIT_PATH,
         });
@@ -152,7 +190,7 @@ export class TurnkeyWallet {
             throw new 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;
@@ -160,35 +198,30 @@ export 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 WalletException(new Error('OTP ID is required'));
         }
-        if (!targetPublicKey) {
-            throw new WalletException(new Error('Target public key not found'));
-        }
-        if (!this.userOrganizationId) {
-            throw new WalletException(new Error('Organization ID is required'));
-        }
         const result = await TurnkeyOtpWallet.confirmEmailOTP({
             otpCode,
+            iframeClient,
             client: this.client,
             emailOTPId: this.otpId,
-            organizationId: this.userOrganizationId,
-            targetPublicKey,
+            organizationId: this.organizationId,
             otpVerifyPath: this.metadata.otpVerifyPath || TURNKEY_OTP_VERIFY_PATH,
         });
-        if (!result || !result.session) {
+        if (!result || !result.credentialBundle) {
             throw new 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 TurnkeyOauthWallet.generateOAuthNonce(indexedDbClient);
+        const iframeClient = await this.getIframeClient();
+        const nonce = await TurnkeyOauthWallet.generateOAuthNonce(iframeClient);
         if (provider === TurnkeyProvider.Apple) {
             // TODO: implement the ability to generate Apple OAuth URL
             return nonce;
@@ -203,10 +236,10 @@ export class TurnkeyWallet {
         });
     }
     async confirmOAuth(provider, oidcToken) {
-        const indexedDbClient = await this.getIndexedDbClient();
+        const iframeClient = await this.getIframeClient();
         const oauthResult = await TurnkeyOauthWallet.oauthLogin({
             oidcToken,
-            indexedDbClient,
+            iframeClient,
             client: this.client,
             providerName: provider.toString(),
             oauthLoginPath: this.metadata.oauthLoginPath || TURNKEY_OAUTH_PATH,
@@ -214,40 +247,53 @@ export class TurnkeyWallet {
         if (!oauthResult || !oauthResult.credentialBundle) {
             throw new 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: SessionType.READ_WRITE,
-                expirationSeconds: this.metadata.expirationSeconds,
+            await this.injectAndRefresh(session.session.token, {
+                expirationSeconds: this.metadata.expirationSeconds || DEFAULT_TURNKEY_REFRESH_SECONDS,
             });
-            this.userOrganizationId = session.organizationId;
             return session.session.token;
         }
         throw new 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;
     }
 }
-async function createTurnkeyClient(metadata) {
+async function createTurnkeyIFrame(metadata) {
     const turnkey = new Turnkey(metadata);
-    const indexedDbClient = await turnkey.indexedDbClient();
-    await indexedDbClient.init();
+    const turnkeyAuthIframeElementId = metadata.iframeElementId || 'turnkey-auth-iframe-element-id';
+    if (!metadata.iframeContainerId) {
+        throw new GeneralException(new Error('iframeContainerId is required'));
+    }
     if (!turnkey) {
         throw new GeneralException(new Error('Turnkey is not initialized'));
     }
+    const iframe = document.getElementById(metadata.iframeContainerId);
+    if (!iframe) {
+        throw new 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/esm/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@injectivelabs/wallet-turnkey",
   "description": "Turnkey wallet strategy for use with @injectivelabs/wallet-core.",
-  "version": "1.16.6-alpha.0",
+  "version": "1.16.6",
   "sideEffects": false,
   "publishConfig": {
     "access": "public"
@@ -44,10 +44,10 @@
     }
   },
   "scripts": {
-    "build": "pnpm build:esm && pnpm build:cjs && pnpm build:post",
+    "build": "yarn build:esm && yarn build:cjs && yarn build:post",
     "build:cjs": "tsc --build --force tsconfig.build.json",
     "build:esm": "tsc --build --force tsconfig.build.esm.json",
-    "build:watch": "tsc --build -w tsconfig.build.json && tsc -w --build tsconfig.build.esm.json && pnpm build:post",
+    "build:watch": "tsc --build -w tsconfig.build.json && tsc -w --build tsconfig.build.esm.json && yarn build:post",
     "build:post": "shx cp ../../../etc/stub/package.json.stub dist/cjs/package.json && shx cp ../../../etc/stub/package.esm.json.stub dist/esm/package.json",
     "clean": "tsc --build tsconfig.build.json --clean && tsc --build tsconfig.build.esm.json --clean && shx rm -rf coverage *.log junit.xml dist && jest --clearCache && shx mkdir -p dist",
     "test": "jest",
@@ -59,14 +59,14 @@
     "start": "node dist/index.js"
   },
   "dependencies": {
-    "@injectivelabs/exceptions": "1.16.6-alpha.0",
-    "@injectivelabs/sdk-ts": "1.16.6-alpha.0",
-    "@injectivelabs/ts-types": "1.16.6-alpha.0",
-    "@injectivelabs/utils": "1.16.6-alpha.0",
-    "@injectivelabs/wallet-base": "1.16.6-alpha.0",
+    "@injectivelabs/exceptions": "^1.16.6",
+    "@injectivelabs/sdk-ts": "^1.16.6",
+    "@injectivelabs/ts-types": "^1.16.6",
+    "@injectivelabs/utils": "^1.16.6",
+    "@injectivelabs/wallet-base": "^1.16.6",
     "@turnkey/sdk-browser": "5.2.3",
-    "@turnkey/viem": "^0.9.10",
-    "viem": "^2.33.2"
+    "@turnkey/viem": "^0.9.9",
+    "viem": "^2.31.3"
   },
   "devDependencies": {
     "jest": "^29.0.0",
@@ -77,5 +77,5 @@
     "tsconfig-paths": "^4.2.0",
     "typescript": "^5.0.0"
   },
-  "gitHead": "b2bd329705e0848283332658754771d45c09d4f7"
+  "gitHead": "41794b09a1047a01dbb1d0e0a473a2f26305752d"
 }