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

package/dist/cjs/index.d.ts

@@ -0,0 +1,3 @@
+export { TurnkeyWalletStrategy } from './strategy/strategy.js';
+export * from './strategy/strategy.js';
+export * from './strategy/turnkey/turnkey.js';

package/dist/cjs/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurnkeyWalletStrategy = void 0;
+var strategy_js_1 = require("./strategy/strategy.js");
+Object.defineProperty(exports, "TurnkeyWalletStrategy", { enumerable: true, get: function () { return strategy_js_1.TurnkeyWalletStrategy; } });
+__exportStar(require("./strategy/strategy.js"), exports);
+__exportStar(require("./strategy/turnkey/turnkey.js"), exports);

package/dist/cjs/package.json

@@ -1,3 +1,3 @@
 {
-  "type": "commonjs"
-}
+    "type": "commonjs"
+}

package/dist/cjs/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/cjs/strategy/Eip1193Provider.js

@@ -0,0 +1,173 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEip1193ProviderForTurnkey = void 0;
+const viemChains = __importStar(require("viem/chains"));
+const viem_1 = require("viem");
+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;
+};
+exports.getEip1193ProviderForTurnkey = getEip1193ProviderForTurnkey;
+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 (0, viem_1.createWalletClient)({
+            chain: this.getChain(),
+            transport: (0, viem_1.http)(),
+        });
+    }
+    getChain() {
+        const chain = (0, viem_1.extractChain)({
+            id: this.chainId,
+            chains: Object.values(viemChains),
+        });
+        return chain;
+    }
+    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 = (0, viem_1.createWalletClient)({
+                account: this.account,
+                chain: this.getChain(),
+                transport: (0, viem_1.http)(),
+            });
+            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 = (0, viem_1.createPublicClient)({
+                chain: this.getChain(),
+                transport: (0, viem_1.http)(),
+            });
+            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/cjs/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/cjs/strategy/consts.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_EVM_CHAIN_CONFIG = exports.DEFAULT_TURNKEY_REFRESH_SECONDS = exports.TURNKEY_OTP_VERIFY_PATH = exports.TURNKEY_OTP_INIT_PATH = exports.TURNKEY_OTP_PATH = exports.TURNKEY_OAUTH_PATH = void 0;
+exports.TURNKEY_OAUTH_PATH = 'turnkey/oauth';
+exports.TURNKEY_OTP_PATH = 'turnkey/otp';
+exports.TURNKEY_OTP_INIT_PATH = `${exports.TURNKEY_OTP_PATH}/init`;
+exports.TURNKEY_OTP_VERIFY_PATH = `${exports.TURNKEY_OTP_PATH}/verify`;
+exports.DEFAULT_TURNKEY_REFRESH_SECONDS = '86400';
+exports.DEFAULT_EVM_CHAIN_CONFIG = {
+    name: 'Injective',
+    nativeCurrency: {
+        name: 'Injective',
+        symbol: 'INJ',
+        decimals: 18,
+    },
+};

package/dist/cjs/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/cjs/strategy/strategy.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurnkeyWalletStrategy = void 0;
+const sdk_ts_1 = require("@injectivelabs/sdk-ts");
+const sdk_ts_2 = require("@injectivelabs/sdk-ts");
+const utils_1 = require("@injectivelabs/utils");
+const viem_1 = require("viem");
+const wallet_base_1 = require("@injectivelabs/wallet-base");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const types_js_1 = require("./types.js");
+const turnkey_js_1 = require("./turnkey/turnkey.js");
+const consts_js_1 = require("./consts.js");
+const Eip1193Provider_js_1 = require("./Eip1193Provider.js");
+class TurnkeyWalletStrategy extends wallet_base_1.BaseConcreteStrategy {
+    turnkeyWallet;
+    evmOptions;
+    client;
+    constructor(args) {
+        super(args);
+        const endpoint = args.apiServerEndpoint || this.metadata?.turnkey?.apiServerEndpoint;
+        if (!endpoint) {
+            throw new exceptions_1.WalletException(new Error('apiServerEndpoint is required'));
+        }
+        this.client = new utils_1.HttpRestClient(endpoint);
+        this.evmOptions = args.evmOptions;
+    }
+    async getWalletDeviceType() {
+        return Promise.resolve(wallet_base_1.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 === types_js_1.TurnkeyErrorCodes.UserLoggedOut) {
+                await this.disconnect();
+                throw e;
+            }
+            throw new exceptions_1.WalletException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: wallet_base_1.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 exceptions_1.WalletException(new Error('Please pass rpcUrl within the evmOptions'), {
+                    code: exceptions_1.UnspecifiedErrorCode,
+                    context: wallet_base_1.WalletAction.SendEvmTransaction,
+                });
+            }
+            const account = await turnkeyWallet.getOrCreateAndGetAccount((0, viem_1.getAddress)(args.address));
+            const accountClient = (0, viem_1.createWalletClient)({
+                account: account,
+                chain: {
+                    ...consts_js_1.DEFAULT_EVM_CHAIN_CONFIG,
+                    id: chainId,
+                    rpcUrls: {
+                        default: {
+                            http: [url],
+                        },
+                    },
+                },
+                transport: (0, viem_1.http)(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 exceptions_1.WalletException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: wallet_base_1.WalletAction.SendEvmTransaction,
+            });
+        }
+    }
+    async sendTransaction(transaction, options) {
+        const { endpoints, txTimeout } = options;
+        if (!endpoints) {
+            throw new exceptions_1.WalletException(new Error('You have to pass endpoints.grpc within the options for using Turnkey wallet'));
+        }
+        const txApi = new sdk_ts_1.TxGrpcApi(endpoints.grpc);
+        const response = await txApi.broadcast(transaction, { txTimeout });
+        if (response.code !== 0) {
+            throw new exceptions_1.TransactionException(new Error(response.rawLog), {
+                code: exceptions_1.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 = (0, viem_1.getAddress)(address);
+        const account = await turnkeyWallet.getOrCreateAndGetAccount(checksumAddress);
+        if (!account) {
+            throw new exceptions_1.WalletException(new Error('Turnkey account not found'));
+        }
+        let parsedData;
+        try {
+            parsedData = JSON.parse(eip712json);
+        }
+        catch {
+            throw new exceptions_1.WalletException(new Error('Failed to parse EIP-712 data: Invalid JSON format'), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: wallet_base_1.WalletAction.SignTransaction,
+            });
+        }
+        const signature = await account.signTypedData(parsedData);
+        return signature;
+    }
+    async signCosmosTransaction(_transaction) {
+        throw new exceptions_1.WalletException(new Error('This wallet does not support signing Cosmos transactions'), {
+            code: exceptions_1.UnspecifiedErrorCode,
+            type: exceptions_1.ErrorType.WalletError,
+            contextModule: wallet_base_1.WalletAction.SignTransaction,
+        });
+    }
+    async signAminoCosmosTransaction(_transaction) {
+        throw new exceptions_1.WalletException(new Error('This wallet does not support signAminoCosmosTransaction'), {
+            code: exceptions_1.UnspecifiedErrorCode,
+            type: exceptions_1.ErrorType.WalletError,
+            contextModule: wallet_base_1.WalletAction.SignTransaction,
+        });
+    }
+    async signArbitrary(_signer, _data) {
+        throw new exceptions_1.WalletException(new Error('This wallet does not support signArbitrary'), {
+            code: exceptions_1.UnspecifiedErrorCode,
+            type: exceptions_1.ErrorType.WalletError,
+            contextModule: wallet_base_1.WalletAction.SignTransaction,
+        });
+    }
+    async getEthereumChainId() {
+        throw new exceptions_1.CosmosWalletException(new Error('getEthereumChainId is not supported on Turnkey wallet'), {
+            code: exceptions_1.UnspecifiedErrorCode,
+            context: wallet_base_1.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 exceptions_1.WalletException(new Error('Please pass rpcUrl within the evmOptions'), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: wallet_base_1.WalletAction.GetEvmTransactionReceipt,
+            });
+        }
+        const publicClient = (0, viem_1.createPublicClient)({
+            chain: {
+                ...consts_js_1.DEFAULT_EVM_CHAIN_CONFIG,
+                id: chainId,
+                rpcUrls: {
+                    default: {
+                        http: [url],
+                    },
+                },
+            },
+            transport: (0, viem_1.http)(url),
+        });
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            attempts++;
+            await (0, utils_1.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 exceptions_1.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 exceptions_1.WalletException(new Error('Turnkey metadata is required'));
+            }
+            if (!metadata.turnkey.apiBaseUrl) {
+                throw new exceptions_1.WalletException(new Error('Turnkey apiBaseUrl is required'));
+            }
+            if (!metadata.turnkey.apiServerEndpoint) {
+                throw new exceptions_1.WalletException(new Error('Turnkey apiServerEndpoint is required'));
+            }
+            this.turnkeyWallet = new turnkey_js_1.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 = (0, viem_1.getAddress)((0, sdk_ts_2.getEthereumAddress)(addresses[0]));
+        const account = await turnkeyWallet.getOrCreateAndGetAccount(checksumAddress);
+        const eip1193Provider = await (0, Eip1193Provider_js_1.getEip1193ProviderForTurnkey)(account, String(this.evmOptions.evmChainId));
+        return eip1193Provider;
+    }
+}
+exports.TurnkeyWalletStrategy = TurnkeyWalletStrategy;

package/dist/cjs/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/cjs/strategy/turnkey/oauth.js

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

package/dist/cjs/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>;
+}