@injectivelabs/wallet-turnkey 1.16.38-alpha.7 → 1.16.38

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

@@ -0,0 +1,3 @@
+import type { LocalAccount } from 'viem';
+import type { Eip1193Provider } from '@injectivelabs/wallet-base';
+export declare const getEip1193ProviderForTurnkey: (account: LocalAccount, chainId: string) => Promise<Eip1193Provider>;

package/dist/esm/strategy/Eip1193Provider.js

@@ -0,0 +1,127 @@
+import { getEvmChainConfig, getViemPublicClient, getViemWalletClient, } from '@injectivelabs/wallet-base';
+export const getEip1193ProviderForTurnkey = async (account, chainId) => {
+    const provider = new CustomEip1193Provider({
+        chainId: parseInt(chainId, 16),
+        signTypedData: account.signTypedData.bind(account),
+        signMessage: account.signMessage.bind(account),
+        signTransaction: account.signTransaction.bind(account),
+        account,
+        address: account.address,
+    });
+    return provider;
+};
+class CustomEip1193Provider {
+    chainId;
+    signTypedData;
+    signMessage;
+    signTransaction;
+    account;
+    address;
+    constructor(args) {
+        this.chainId = args.chainId ?? 1;
+        this.signTypedData = args.signTypedData;
+        this.signMessage = args.signMessage;
+        this.account = args.account;
+        this.address = args.address;
+        this.signTransaction = args.signTransaction;
+    }
+    async requestAccounts() {
+        return [this.address];
+    }
+    getClient() {
+        return getViemWalletClient({
+            chainId: this.chainId,
+            account: this.account,
+        });
+    }
+    getChain() {
+        return getEvmChainConfig(this.chainId);
+    }
+    on(_event, _listener) {
+        throw new Error('Not implemented');
+    }
+    removeListener(..._args) {
+        throw new Error('Not implemented!');
+    }
+    async request(args) {
+        if (args.method === 'eth_requestAccounts') {
+            return this.requestAccounts();
+        }
+        if (args.method === 'eth_signTypedData') {
+            if (!args.params) {
+                throw new Error('params is required');
+            }
+            return this.signTypedData(args.params[0]);
+        }
+        if (args.method === 'eth_signMessage') {
+            if (!args.params) {
+                throw new Error('params is required');
+            }
+            return this.signMessage(args.params[0]);
+        }
+        if (args.method === 'eth_chainId') {
+            return this.chainId;
+        }
+        if (args.method === 'wallet_switchEthereumChain') {
+            if (!args.params) {
+                throw new Error('params is required');
+            }
+            const chainId = String(args.params[0].chainId).replace('0x', '');
+            this.chainId = parseInt(chainId, 16);
+            return true;
+        }
+        if (args.method === 'eth_sendTransaction') {
+            if (!args.params) {
+                throw new Error('params is required');
+            }
+            const accountClient = getViemWalletClient({
+                chainId: this.chainId,
+                account: this.account,
+            });
+            const client = this.getClient();
+            const parseHexValue = (value) => {
+                if (typeof value === 'string') {
+                    const hexValue = value.startsWith('0x') ? value : `0x${value}`;
+                    return BigInt(hexValue);
+                }
+                return BigInt(value);
+            };
+            const txData = args.params[0];
+            const processedTransaction = { ...txData };
+            const hexFields = [
+                'value',
+                'gas',
+                'gasLimit',
+                'gasPrice',
+                'maxFeePerGas',
+                'maxPriorityFeePerGas',
+            ];
+            for (const field of hexFields) {
+                if (processedTransaction[field] !== undefined) {
+                    processedTransaction[field] = parseHexValue(processedTransaction[field]);
+                }
+            }
+            const preparedTransaction = await accountClient.prepareTransactionRequest(processedTransaction);
+            const signedTransaction = await this.signTransaction(preparedTransaction);
+            const tx = await client.sendRawTransaction({
+                serializedTransaction: signedTransaction,
+            });
+            return tx;
+        }
+        if (args.method === 'eth_getTransactionCount') {
+            if (!args.params) {
+                throw new Error('params is required');
+            }
+            const client = getViemPublicClient(this.chainId);
+            const count = await client.getTransactionCount({
+                address: this.address,
+                blockTag: 'pending',
+            });
+            return `0x${count.toString(16)}`;
+        }
+        return this.getClient().request({
+            method: args.method,
+            params: args.params,
+        });
+    }
+}

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

@@ -0,0 +1,13 @@
+export declare const TURNKEY_OAUTH_PATH = "turnkey/oauth";
+export declare const TURNKEY_OTP_PATH = "turnkey/otp";
+export declare const TURNKEY_OTP_INIT_PATH = "turnkey/otp/init";
+export declare const TURNKEY_OTP_VERIFY_PATH = "turnkey/otp/verify";
+export declare const DEFAULT_TURNKEY_REFRESH_SECONDS = "86400";
+export declare const DEFAULT_EVM_CHAIN_CONFIG: {
+    name: string;
+    nativeCurrency: {
+        name: string;
+        symbol: string;
+        decimals: number;
+    };
+};

package/dist/esm/strategy/consts.js

@@ -0,0 +1,13 @@
+export const TURNKEY_OAUTH_PATH = 'turnkey/oauth';
+export const TURNKEY_OTP_PATH = 'turnkey/otp';
+export const TURNKEY_OTP_INIT_PATH = `${TURNKEY_OTP_PATH}/init`;
+export const TURNKEY_OTP_VERIFY_PATH = `${TURNKEY_OTP_PATH}/verify`;
+export const DEFAULT_TURNKEY_REFRESH_SECONDS = '86400';
+export const DEFAULT_EVM_CHAIN_CONFIG = {
+    name: 'Injective',
+    nativeCurrency: {
+        name: 'Injective',
+        symbol: 'INJ',
+        decimals: 18,
+    },
+};

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

@@ -0,0 +1,48 @@
+import { HttpRestClient } from '@injectivelabs/utils';
+import { WalletDeviceType, type WalletMetadata, BaseConcreteStrategy } from '@injectivelabs/wallet-base';
+import { TurnkeyWallet } from './turnkey/turnkey.js';
+import type { EvmChainId } from '@injectivelabs/ts-types';
+import type { AccountAddress } from '@injectivelabs/ts-types';
+import type { TurnkeyIndexedDbClient } from '@turnkey/sdk-browser';
+import type { TxRaw, AminoSignResponse, DirectSignResponse } from '@injectivelabs/sdk-ts';
+import type { StdSignDoc, Eip1193Provider, ConcreteWalletStrategy, SendTransactionOptions, WalletStrategyEvmOptions, ConcreteEvmWalletStrategyArgs } from '@injectivelabs/wallet-base';
+export declare class TurnkeyWalletStrategy extends BaseConcreteStrategy implements ConcreteWalletStrategy {
+    turnkeyWallet?: TurnkeyWallet;
+    evmOptions: WalletStrategyEvmOptions;
+    client: HttpRestClient;
+    constructor(args: ConcreteEvmWalletStrategyArgs & {
+        apiServerEndpoint?: string;
+    });
+    getWalletDeviceType(): Promise<WalletDeviceType>;
+    setMetadata(metadata?: {
+        turnkey?: Partial<WalletMetadata['turnkey']>;
+    }): void;
+    enable(): Promise<boolean>;
+    disconnect(): Promise<void>;
+    getAddresses(): Promise<string[]>;
+    getSessionOrConfirm(_address?: string): Promise<string>;
+    getWalletClient<TurnkeyWallet>(): Promise<TurnkeyWallet>;
+    sendEvmTransaction(transaction: unknown, args: {
+        address: AccountAddress;
+        evmChainId: EvmChainId;
+    }): Promise<string>;
+    sendTransaction(transaction: TxRaw, options: SendTransactionOptions): Promise<any>;
+    signEip712TypedData(eip712json: string, address: AccountAddress): Promise<string>;
+    signCosmosTransaction(_transaction: {
+        txRaw: TxRaw;
+        accountNumber: number;
+        chainId: string;
+        address: string;
+    }): Promise<DirectSignResponse>;
+    signAminoCosmosTransaction(_transaction: {
+        address: string;
+        signDoc: StdSignDoc;
+    }): Promise<AminoSignResponse>;
+    signArbitrary(_signer: AccountAddress, _data: string | Uint8Array): Promise<string>;
+    getEthereumChainId(): Promise<string>;
+    getEvmTransactionReceipt(txHash: string, evmChainId?: EvmChainId): Promise<Record<string, any>>;
+    getPubKey(): Promise<string>;
+    getIndexedDbClient(): Promise<TurnkeyIndexedDbClient>;
+    private getTurnkeyWallet;
+    getEip1193Provider(): Promise<Eip1193Provider>;
+}

package/dist/esm/strategy/strategy.js

@@ -0,0 +1,271 @@
+import { getAddress } from 'viem';
+import { TxGrpcApi } from '@injectivelabs/sdk-ts';
+import { getEthereumAddress } from '@injectivelabs/sdk-ts';
+import { sleep, HttpRestClient } from '@injectivelabs/utils';
+import { ErrorType, WalletException, UnspecifiedErrorCode, TransactionException, CosmosWalletException, } from '@injectivelabs/exceptions';
+import { WalletAction, WalletDeviceType, getViemWalletClient, getViemPublicClient, BaseConcreteStrategy, } from '@injectivelabs/wallet-base';
+import { TurnkeyErrorCodes } from './types.js';
+import { TurnkeyWallet } from './turnkey/turnkey.js';
+import { getEip1193ProviderForTurnkey } from './Eip1193Provider.js';
+export class TurnkeyWalletStrategy extends BaseConcreteStrategy {
+    turnkeyWallet;
+    evmOptions;
+    client;
+    constructor(args) {
+        super(args);
+        const endpoint = args.apiServerEndpoint || this.metadata?.turnkey?.apiServerEndpoint;
+        if (!endpoint) {
+            throw new WalletException(new Error('apiServerEndpoint is required'));
+        }
+        this.client = new HttpRestClient(endpoint);
+        this.evmOptions = args.evmOptions;
+    }
+    async getWalletDeviceType() {
+        return Promise.resolve(WalletDeviceType.Browser);
+    }
+    setMetadata(metadata) {
+        if (metadata?.turnkey) {
+            this.metadata = {
+                ...this.metadata,
+                turnkey: {
+                    ...this.metadata?.turnkey,
+                    ...metadata.turnkey,
+                },
+            };
+            this.turnkeyWallet?.setMetadata(this.metadata?.turnkey);
+        }
+    }
+    async enable() {
+        const turnkeyWallet = await this.getTurnkeyWallet();
+        try {
+            const session = await turnkeyWallet.getSession();
+            if (session.session) {
+                // User is already logged in, we don't need to do anything in the next steps
+                if (this.metadata?.turnkey) {
+                    this.metadata.turnkey.session = session.session;
+                }
+                return true;
+            }
+            return !!(await turnkeyWallet.getIndexedDbClient());
+        }
+        catch {
+            return false;
+        }
+    }
+    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()]);
+    }
+    async getAddresses() {
+        const turnkeyWallet = await this.getTurnkeyWallet();
+        try {
+            return await turnkeyWallet.getAccounts();
+        }
+        catch (e) {
+            if (e.contextCode === TurnkeyErrorCodes.UserLoggedOut) {
+                await this.disconnect();
+                throw e;
+            }
+            throw new WalletException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: WalletAction.GetAccounts,
+            });
+        }
+    }
+    async getSessionOrConfirm(_address) {
+        const turnkeyWallet = await this.getTurnkeyWallet();
+        return await turnkeyWallet.refreshSession();
+    }
+    async getWalletClient() {
+        return (await this.getTurnkeyWallet());
+    }
+    async sendEvmTransaction(transaction, args) {
+        try {
+            const options = this.evmOptions;
+            const turnkeyWallet = await this.getTurnkeyWallet();
+            const chainId = args.evmChainId || options.evmChainId;
+            const url = options.rpcUrl || options.rpcUrls?.[args.evmChainId];
+            if (!url) {
+                throw new WalletException(new Error('Please pass rpcUrl within the evmOptions'), {
+                    code: UnspecifiedErrorCode,
+                    context: WalletAction.SendEvmTransaction,
+                });
+            }
+            const account = await turnkeyWallet.getOrCreateAndGetAccount(getAddress(args.address));
+            const accountClient = getViemWalletClient({
+                chainId,
+                account: account,
+                rpcUrl: url,
+            });
+            const parseHexValue = (value) => {
+                if (typeof value === 'string') {
+                    const hexValue = value.startsWith('0x') ? value : `0x${value}`;
+                    return BigInt(hexValue);
+                }
+                return BigInt(value);
+            };
+            const txData = transaction;
+            const processedTransaction = { ...txData };
+            const hexFields = [
+                'value',
+                'gas',
+                'gasLimit',
+                'gasPrice',
+                'maxFeePerGas',
+                'maxPriorityFeePerGas',
+            ];
+            for (const field of hexFields) {
+                if (processedTransaction[field] !== undefined) {
+                    processedTransaction[field] = parseHexValue(processedTransaction[field]);
+                }
+            }
+            const preparedTransaction = await accountClient.prepareTransactionRequest(processedTransaction);
+            delete preparedTransaction.account;
+            const signedTransaction = await accountClient.signTransaction(preparedTransaction);
+            const tx = await accountClient.sendRawTransaction({
+                serializedTransaction: signedTransaction,
+            });
+            return tx;
+        }
+        catch (e) {
+            throw new WalletException(e, {
+                code: UnspecifiedErrorCode,
+                context: WalletAction.SendEvmTransaction,
+            });
+        }
+    }
+    async sendTransaction(transaction, options) {
+        const { endpoints, txTimeout } = options;
+        if (!endpoints) {
+            throw new WalletException(new Error('You have to pass endpoints.grpc within the options for using Turnkey wallet'));
+        }
+        const txApi = new TxGrpcApi(endpoints.grpc);
+        const response = await txApi.broadcast(transaction, { txTimeout });
+        if (response.code !== 0) {
+            throw new TransactionException(new Error(response.rawLog), {
+                code: UnspecifiedErrorCode,
+                contextCode: response.code,
+                contextModule: response.codespace,
+            });
+        }
+        return response;
+    }
+    async signEip712TypedData(eip712json, address) {
+        const turnkeyWallet = await this.getTurnkeyWallet();
+        //? 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);
+        if (!account) {
+            throw new WalletException(new Error('Turnkey account not found'));
+        }
+        let parsedData;
+        try {
+            parsedData = JSON.parse(eip712json);
+        }
+        catch {
+            throw new WalletException(new Error('Failed to parse EIP-712 data: Invalid JSON format'), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: WalletAction.SignTransaction,
+            });
+        }
+        const signature = await account.signTypedData(parsedData);
+        return signature;
+    }
+    async signCosmosTransaction(_transaction) {
+        throw new WalletException(new Error('This wallet does not support signing Cosmos transactions'), {
+            code: UnspecifiedErrorCode,
+            type: ErrorType.WalletError,
+            contextModule: WalletAction.SignTransaction,
+        });
+    }
+    async signAminoCosmosTransaction(_transaction) {
+        throw new WalletException(new Error('This wallet does not support signAminoCosmosTransaction'), {
+            code: UnspecifiedErrorCode,
+            type: ErrorType.WalletError,
+            contextModule: WalletAction.SignTransaction,
+        });
+    }
+    async signArbitrary(_signer, _data) {
+        throw new WalletException(new Error('This wallet does not support signArbitrary'), {
+            code: UnspecifiedErrorCode,
+            type: ErrorType.WalletError,
+            contextModule: WalletAction.SignTransaction,
+        });
+    }
+    async getEthereumChainId() {
+        throw new CosmosWalletException(new Error('getEthereumChainId is not supported on Turnkey wallet'), {
+            code: UnspecifiedErrorCode,
+            context: WalletAction.GetChainId,
+        });
+    }
+    async getEvmTransactionReceipt(txHash, evmChainId) {
+        const options = this.evmOptions;
+        const maxAttempts = 10;
+        const interval = 3000;
+        const chainId = evmChainId || options.evmChainId;
+        const url = options.rpcUrl || options.rpcUrls?.[chainId];
+        if (!url) {
+            throw new WalletException(new Error('Please pass rpcUrl within the evmOptions'), {
+                code: UnspecifiedErrorCode,
+                context: WalletAction.GetEvmTransactionReceipt,
+            });
+        }
+        const publicClient = getViemPublicClient(chainId, url);
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            attempts++;
+            await sleep(interval);
+            try {
+                const receipt = await publicClient.getTransactionReceipt({
+                    hash: txHash,
+                });
+                if (receipt) {
+                    return receipt;
+                }
+            }
+            catch { }
+        }
+        throw new Error(`Failed to retrieve transaction receipt for txHash: ${txHash}`);
+    }
+    async getPubKey() {
+        throw new WalletException(new Error('You can only fetch PubKey from Cosmos native wallets'));
+    }
+    async getIndexedDbClient() {
+        const turnkeyWallet = await this.getTurnkeyWallet();
+        const indexedDbClient = await turnkeyWallet.getIndexedDbClient();
+        return indexedDbClient;
+    }
+    async getTurnkeyWallet() {
+        const { metadata } = this;
+        if (!this.turnkeyWallet) {
+            if (!metadata?.turnkey) {
+                throw new WalletException(new Error('Turnkey metadata is required'));
+            }
+            if (!metadata.turnkey.apiBaseUrl) {
+                throw new WalletException(new Error('Turnkey apiBaseUrl is required'));
+            }
+            if (!metadata.turnkey.apiServerEndpoint) {
+                throw new WalletException(new Error('Turnkey apiServerEndpoint is required'));
+            }
+            this.turnkeyWallet = new TurnkeyWallet(metadata.turnkey);
+        }
+        return this.turnkeyWallet;
+    }
+    async getEip1193Provider() {
+        const turnkeyWallet = await this.getTurnkeyWallet();
+        const addresses = await turnkeyWallet.getAccounts();
+        //? 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(getEthereumAddress(addresses[0]));
+        const account = await turnkeyWallet.getOrCreateAndGetAccount(checksumAddress);
+        const eip1193Provider = await getEip1193ProviderForTurnkey(account, String(this.evmOptions.evmChainId));
+        return eip1193Provider;
+    }
+}

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

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

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

@@ -0,0 +1,49 @@
+import { sha256 } from '@injectivelabs/sdk-ts';
+import { ErrorType, WalletException, UnspecifiedErrorCode, } from '@injectivelabs/exceptions';
+import { TURNKEY_OAUTH_PATH, DEFAULT_TURNKEY_REFRESH_SECONDS, } from '../consts.js';
+export class TurnkeyOauthWallet {
+    static async generateOAuthNonce(indexedDbClient) {
+        try {
+            await indexedDbClient.resetKeyPair();
+            const targetPublicKey = await indexedDbClient.getPublicKey();
+            if (!targetPublicKey) {
+                throw new WalletException(new Error('Target public key not found'));
+            }
+            return Array.from(sha256(new TextEncoder().encode(targetPublicKey)))
+                .map((b) => b.toString(16).padStart(2, '0'))
+                .join('');
+        }
+        catch (e) {
+            throw new WalletException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: 'turnkey-generate-oauth-nonce',
+            });
+        }
+    }
+    static async oauthLogin(args) {
+        const { client, indexedDbClient, expirationSeconds } = args;
+        const path = args.oauthLoginPath || TURNKEY_OAUTH_PATH;
+        try {
+            const targetPublicKey = await indexedDbClient.getPublicKey();
+            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(path, {
+                targetPublicKey,
+                oidcToken: args.oidcToken,
+                providerName: args.providerName,
+                expirationSeconds: (expirationSeconds || DEFAULT_TURNKEY_REFRESH_SECONDS)?.toString(),
+            });
+            return response.data;
+        }
+        catch (e) {
+            throw new WalletException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: 'turnkey-oauth-login',
+            });
+        }
+    }
+}

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

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

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

@@ -0,0 +1,61 @@
+import { ErrorType, WalletException, UnspecifiedErrorCode, } from '@injectivelabs/exceptions';
+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;
+        try {
+            await indexedDbClient.resetKeyPair();
+            let publicKey = await indexedDbClient.getPublicKey();
+            if (!publicKey) {
+                throw new WalletException(new Error('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,
+                email: args.email,
+                suborgId: args.subOrgId,
+                invalidateExistingSessions: args.invalidateExistingSessions,
+                isUsingIndexedDB: true,
+                expirationSeconds: expirationSeconds || DEFAULT_TURNKEY_REFRESH_SECONDS,
+            });
+            return response?.data;
+        }
+        catch (e) {
+            throw new WalletException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: 'turnkey-init-email-otp',
+            });
+        }
+    }
+    static async confirmEmailOTP(args) {
+        const { client, expirationSeconds, targetPublicKey } = args;
+        try {
+            const organizationId = args.organizationId;
+            const emailOTPId = args.emailOTPId;
+            const otpVerifyPath = args.otpVerifyPath || TURNKEY_OTP_VERIFY_PATH;
+            if (!emailOTPId) {
+                throw new WalletException(new Error('Email OTP ID is required'));
+            }
+            if (!organizationId) {
+                throw new WalletException(new Error('Organization ID is required'));
+            }
+            const response = await client.post(otpVerifyPath, {
+                isUsingIndexedDB: true,
+                targetPublicKey,
+                otpId: emailOTPId,
+                otpCode: args.otpCode,
+                suborgID: organizationId,
+                expirationSeconds: (expirationSeconds || DEFAULT_TURNKEY_REFRESH_SECONDS)?.toString(),
+            });
+            return response?.data;
+        }
+        catch (e) {
+            throw new WalletException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: 'turnkey-confirm-email-otp',
+            });
+        }
+    }
+}

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

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