@injectivelabs/wallet-turnkey 1.15.10

package/README.md

@@ -0,0 +1,120 @@
+# 🌟 Injective Protocol - Turnkey Wallet Strategy
+
+[![downloads](https://img.shields.io/npm/dm/@injectivelabs/wallet-turnkey.svg)](https://www.npmjs.com/package/@injectivelabs/wallet-turnkey)
+[![npm-version](https://img.shields.io/npm/v/@injectivelabs/wallet-turnkey.svg)](https://www.npmjs.com/package/@injectivelabs/wallet-turnkey)
+[![license](https://img.shields.io/npm/l/express.svg)]()
+
+_Package to use Turnkey Wallet on Injective via the wallet strategy._
+
+---
+
+## 📚 Installation
+
+```bash
+yarn add @injectivelabs/wallet-turnkey
+```
+
+---
+
+## 📖 Documentation
+
+Injective's wallet packages are intended to make it easy for developers to choose exactly what wallets - and subsequent dependencies - they
+want to include in their projects.
+
+Regardless of which wallet package(s) you choose to use you must also have `@injectivelabs/wallet-core` and `@injectivelabs/wallet-base`
+installed. These contain all of the types and core wallet functionality, with the separate wallet packages only providing the necessary
+dependencies and implementations for their specific wallets.
+
+Here's a brief example of how to use this package to send 1 INJ.:
+
+```typescript
+import { Wallet } from '@injectivelabs/wallet-base';
+import { BaseWalletStrategy, MsgBroadcaster } from '@injectivelabs/wallet-core';
+import { TurnkeyWallet } from '@injectivelabs/wallet-turnkey';
+
+
+const strategyArgs: WalletStrategyArguments = {
+  chainId: ChainId.Mainnet,
+  wallet: Wallet.Turnkey,
+  strategies: {
+        [Wallet.Turnkey]: new TurnkeyWallet({
+        onStatusChange(status) {
+          turnkeyStatus.value = status
+        },
+        chainId: injectiveClients.chainId,
+        ethereumOptions: {
+          ethereumChainId: injectiveClients.ethereumChainId!,
+        },
+        metadata: {
+          turnkeyAuthIframeContainerId,
+          defaultOrganizationId: import.meta.env
+            .VITE_TURNKEY_DEFAULT_ORGANIZATION_ID,
+          apiBaseUrl: 'https://api.turnkey.com',
+        },
+      })
+  },
+}
+const walletStrategy = new BaseWalletStrategy(strategyArgs)
+
+const msgBroadcaster = new MsgBroadcaster({
+  walletStrategy,
+  simulateTx: true,
+  network: Network.Mainnet,
+  ethereumChainId: injectiveClients.ethereumChainId!,
+  endpoints: injectiveClients.endpoints,
+})
+
+const sendTX = async () => {
+    const injectiveAddress = 'someInjectiveAddress'
+
+    const message = MsgSend.fromJSON({
+      srcInjectiveAddress: injectiveAddress,
+      dstInjectiveAddress: injectiveAddress,
+      amount: {
+        amount: '1',
+        denom: 'inj',
+      },
+    })
+
+    return await msgBroadcaster.broadcast({ msgs: message })
+  }
+
+  const result = await sendTX()
+```
+
+Read more and find example usages on our [WalletStrategy Docs](https://docs.ts.injective.network/wallet/wallet-wallet-strategy)
+
+---
+
+## 📜 Contribution
+
+**Contribution guides and practices will be available once there is a stable foundation of the whole package set within the `injective-ts` repo.**
+
+---
+
+## ⛑ Support
+
+Reach out to us at one of the following places!
+
+- Website at <a href="https://injective.com" target="_blank">`injective.com`</a>
+- Twitter at <a href="https://twitter.com/Injective_" target="_blank">`@Injective`</a>
+- Discord at <a href="https://discord.com/invite/NK4qdbv" target="_blank">`Discord`</a>
+- Telegram at <a href="https://t.me/joininjective" target="_blank">`Telegram`</a>
+
+---
+
+## 🔓 License
+
+Copyright © 2021 - 2022 Injective Labs Inc. (https://injectivelabs.org/)
+
+<a href="https://iili.io/mNneZN.md.png"><img src="https://iili.io/mNneZN.md.png" style="width: 300px; max-width: 100%; height: auto" />
+
+Originally released by Injective Labs Inc. under: <br />
+Apache License <br />
+Version 2.0, January 2004 <br />
+http://www.apache.org/licenses/
+
+<p>&nbsp;</p>
+<div align="center">
+  <sub><em>Powering the future of decentralized finance.</em></sub>
+</div>

package/dist/cjs/index.d.ts

@@ -0,0 +1,4 @@
+export { TurnkeyOtpWalletStrategy } from './strategy/strategy/otp.js';
+export { TurnkeyOauthWalletStrategy } from './strategy/strategy/oauth.js';
+export * from './strategy/strategy/base.js';
+export * from './strategy/turnkey/turnkey.js';

package/dist/cjs/index.js

@@ -0,0 +1,23 @@
+"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.TurnkeyOauthWalletStrategy = exports.TurnkeyOtpWalletStrategy = void 0;
+var otp_js_1 = require("./strategy/strategy/otp.js");
+Object.defineProperty(exports, "TurnkeyOtpWalletStrategy", { enumerable: true, get: function () { return otp_js_1.TurnkeyOtpWalletStrategy; } });
+var oauth_js_1 = require("./strategy/strategy/oauth.js");
+Object.defineProperty(exports, "TurnkeyOauthWalletStrategy", { enumerable: true, get: function () { return oauth_js_1.TurnkeyOauthWalletStrategy; } });
+__exportStar(require("./strategy/strategy/base.js"), exports);
+__exportStar(require("./strategy/turnkey/turnkey.js"), exports);

package/dist/cjs/package.json

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

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

@@ -0,0 +1,4 @@
+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";

package/dist/cjs/strategy/consts.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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`;

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

@@ -0,0 +1,47 @@
+import { TxRaw, AminoSignResponse, DirectSignResponse } from '@injectivelabs/sdk-ts';
+import { HttpRestClient } from '@injectivelabs/utils';
+import { AccountAddress, EthereumChainId } from '@injectivelabs/ts-types';
+import { StdSignDoc, TurnkeyProvider, WalletDeviceType, type WalletMetadata, BaseConcreteStrategy, ConcreteWalletStrategy, SendTransactionOptions, ConcreteEthereumWalletStrategyArgs } from '@injectivelabs/wallet-base';
+import { TurnkeyWallet } from '../turnkey/turnkey.js';
+import { TurnkeyIframeClient } from '@turnkey/sdk-browser';
+export declare class BaseTurnkeyWalletStrategy extends BaseConcreteStrategy implements ConcreteWalletStrategy {
+    turnkeyWallet: TurnkeyWallet | undefined;
+    turnkeyProvider: TurnkeyProvider;
+    client: HttpRestClient;
+    constructor(args: ConcreteEthereumWalletStrategyArgs & {
+        provider: TurnkeyProvider;
+        apiServerEndpoint?: string;
+    });
+    getWalletDeviceType(): Promise<WalletDeviceType>;
+    setMetadata(metadata?: {
+        turnkey?: Partial<WalletMetadata['turnkey']>;
+    }): void;
+    private setOrganizationId;
+    enable(): Promise<boolean>;
+    disconnect(): Promise<void>;
+    getAddresses(): Promise<string[]>;
+    getSessionOrConfirm(): Promise<string>;
+    sendEthereumTransaction(_transaction: unknown, _options: {
+        address: AccountAddress;
+        ethereumChainId: EthereumChainId;
+    }): 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>;
+    getEthereumTransactionReceipt(_txHash: string): Promise<string>;
+    getPubKey(): Promise<string>;
+    getIframeClient(): Promise<TurnkeyIframeClient>;
+    private getTurnkeyWallet;
+    private getOrganizationId;
+}

package/dist/cjs/strategy/strategy/base.js

@@ -0,0 +1,327 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTurnkeyWalletStrategy = void 0;
+/* eslint-disable class-methods-use-this */
+const exceptions_1 = require("@injectivelabs/exceptions");
+const sdk_ts_1 = require("@injectivelabs/sdk-ts");
+const utils_1 = require("@injectivelabs/utils");
+const wallet_base_1 = require("@injectivelabs/wallet-base");
+const turnkey_js_1 = require("../turnkey/turnkey.js");
+const types_js_1 = require("../types.js");
+const otp_js_1 = require("../turnkey/otp.js");
+const oauth_js_1 = require("../turnkey/oauth.js");
+const sdk_browser_1 = require("@turnkey/sdk-browser");
+const viem_1 = require("viem");
+const utils_js_1 = require("../../utils.js");
+class BaseTurnkeyWalletStrategy extends wallet_base_1.BaseConcreteStrategy {
+    turnkeyWallet;
+    turnkeyProvider;
+    client;
+    constructor(args) {
+        super(args);
+        this.turnkeyProvider = args.provider;
+        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);
+    }
+    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 is here specifically because we have to ensure we set the organizationId on TurnkeyWallet as well
+    setOrganizationId(organizationId) {
+        this.setMetadata({ turnkey: { organizationId } });
+        this.turnkeyWallet?.setMetadata({ organizationId });
+    }
+    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.getIframeClient());
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async disconnect() {
+        const turnkeyWallet = await this.getTurnkeyWallet();
+        const turnkey = await turnkeyWallet.getTurnkey();
+        const isUserLoggedIn = await turnkey.getSession();
+        if (!isUserLoggedIn) {
+            return;
+        }
+        await turnkey.logout();
+    }
+    async getAddresses() {
+        const turnkeyWallet = await this.getTurnkeyWallet();
+        const organizationId = await this.getOrganizationId();
+        // CHeck if the user is already connected
+        const session = await turnkeyWallet.getSession();
+        if (!session.session) {
+            const iframeClient = await turnkeyWallet.getIframeClient();
+            // Check the provider type and perform auth step accordingly
+            if (this.turnkeyProvider === wallet_base_1.TurnkeyProvider.Email) {
+                if (!this.metadata?.turnkey?.otpId) {
+                    throw new exceptions_1.WalletException(new Error('OTP ID is required'));
+                }
+                if (!this.metadata?.turnkey?.otpCode) {
+                    throw new exceptions_1.WalletException(new Error('OTP code is required'));
+                }
+                const result = await otp_js_1.TurnkeyOtpWallet.confirmEmailOTP({
+                    iframeClient,
+                    organizationId,
+                    client: this.client,
+                    otpCode: this.metadata?.turnkey?.otpCode,
+                    emailOTPId: this.metadata?.turnkey?.otpId,
+                });
+                if (result?.credentialBundle) {
+                    this.metadata.turnkey.credentialBundle = result.credentialBundle;
+                    await turnkeyWallet.injectAndRefresh(result.credentialBundle);
+                }
+            }
+            else {
+                if (!this.metadata?.turnkey?.oidcToken) {
+                    throw new exceptions_1.WalletException(new Error('Oidc token is required'));
+                }
+                const result = await oauth_js_1.TurnkeyOauthWallet.oauthLogin({
+                    client: this.client,
+                    iframeClient,
+                    oidcToken: this.metadata?.turnkey?.oidcToken,
+                    providerName: this.turnkeyProvider.toString(),
+                });
+                if (result?.credentialBundle) {
+                    this.metadata.turnkey.organizationId = result.organizationId;
+                    this.metadata.turnkey.credentialBundle = result.credentialBundle;
+                    await turnkeyWallet.injectAndRefresh(result.credentialBundle);
+                }
+            }
+        }
+        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() {
+        const { turnkeyProvider, metadata, client } = this;
+        const turnkeyWallet = await this.getTurnkeyWallet();
+        const iframeClient = await turnkeyWallet.getIframeClient();
+        const session = await turnkeyWallet.getSession();
+        if (
+        // If either of these values exist on the metadata, then we want to proceed with the login flow
+        !this.metadata?.turnkey?.email &&
+            !this.metadata?.turnkey?.oidcToken &&
+            session.session?.token) {
+            await iframeClient.injectCredentialBundle(session.session?.token);
+            this.setOrganizationId(session.organizationId);
+            await iframeClient.refreshSession({
+                sessionType: sdk_browser_1.SessionType.READ_WRITE,
+                targetPublicKey: iframeClient.iframePublicKey,
+                expirationSeconds: '900',
+            });
+            return session.session.token;
+        }
+        if (turnkeyProvider === wallet_base_1.TurnkeyProvider.Email) {
+            if (!metadata?.turnkey?.email) {
+                throw new exceptions_1.WalletException(new Error('Email is required'));
+            }
+            const result = await otp_js_1.TurnkeyOtpWallet.initEmailOTP({
+                client,
+                iframeClient,
+                email: metadata.turnkey.email,
+                otpInitPath: metadata.turnkey.otpInitPath,
+            });
+            if (result?.organizationId && this.metadata?.turnkey) {
+                this.metadata.turnkey.organizationId = result.organizationId;
+            }
+            if (result?.otpId && this.metadata?.turnkey) {
+                this.metadata.turnkey.otpId = result.otpId;
+            }
+            return result?.otpId || '';
+        }
+        if ([wallet_base_1.TurnkeyProvider.Google, wallet_base_1.TurnkeyProvider.Apple].includes(turnkeyProvider)) {
+            if (metadata?.turnkey?.oidcToken) {
+                const oauthResult = await oauth_js_1.TurnkeyOauthWallet.oauthLogin({
+                    client,
+                    iframeClient,
+                    oidcToken: metadata.turnkey.oidcToken,
+                    providerName: turnkeyProvider.toString(),
+                    oauthLoginPath: metadata.turnkey.oauthLoginPath,
+                });
+                if (oauthResult?.credentialBundle) {
+                    await turnkeyWallet.injectAndRefresh(oauthResult.credentialBundle);
+                }
+                if (oauthResult?.credentialBundle) {
+                    const session = await turnkeyWallet.getSession();
+                    if (this.metadata?.turnkey && session.organizationId) {
+                        this.metadata.turnkey.organizationId = session.organizationId;
+                    }
+                    return oauthResult.credentialBundle;
+                }
+                throw new exceptions_1.WalletException(new Error('Oauth result not found'));
+            }
+            else {
+                const nonce = await oauth_js_1.TurnkeyOauthWallet.generateOAuthNonce(iframeClient);
+                if (!metadata?.turnkey?.googleClientId ||
+                    !metadata?.turnkey?.googleRedirectUri) {
+                    throw new exceptions_1.WalletException(new Error('googleClientId and googleRedirectUri are required'));
+                }
+                if (turnkeyProvider === wallet_base_1.TurnkeyProvider.Google) {
+                    return (0, utils_js_1.generateGoogleUrl)({
+                        nonce,
+                        clientId: metadata.turnkey.googleClientId,
+                        redirectUri: metadata.turnkey.googleRedirectUri,
+                    });
+                }
+                //? When we add Apple support, we might also want to return the URL as well
+                return nonce;
+            }
+        }
+        return '';
+    }
+    async sendEthereumTransaction(_transaction, _options) {
+        throw new exceptions_1.WalletException(new Error('sendEthereumTransaction is not supported. Turnkey only supports sending cosmos transactions'), {
+            code: exceptions_1.UnspecifiedErrorCode,
+            context: wallet_base_1.WalletAction.SendEthereumTransaction,
+        });
+    }
+    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();
+        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 = (0, viem_1.getAddress)(address);
+        const account = await turnkeyWallet.getOrCreateAndGetAccount(checksumAddress, organizationId);
+        if (!account) {
+            throw new exceptions_1.WalletException(new Error('Turnkey account not found'));
+        }
+        let parsedData;
+        try {
+            parsedData = JSON.parse(eip712json);
+        }
+        catch (e) {
+            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;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    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 getEthereumTransactionReceipt(_txHash) {
+        throw new exceptions_1.CosmosWalletException(new Error('getEthereumTransactionReceipt is not supported on Turnkey'), {
+            code: exceptions_1.UnspecifiedErrorCode,
+            type: exceptions_1.ErrorType.WalletError,
+            context: wallet_base_1.WalletAction.GetEthereumTransactionReceipt,
+        });
+    }
+    // eslint-disable-next-line class-methods-use-this
+    async getPubKey() {
+        throw new exceptions_1.WalletException(new Error('You can only fetch PubKey from Cosmos native wallets'));
+    }
+    async getIframeClient() {
+        const turnkeyWallet = await this.getTurnkeyWallet();
+        return turnkeyWallet.getIframeClient();
+    }
+    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'));
+            }
+            if (!metadata.turnkey.defaultOrganizationId) {
+                throw new exceptions_1.WalletException(new Error('Turnkey defaultOrganizationId is required'));
+            }
+            this.turnkeyWallet = new turnkey_js_1.TurnkeyWallet(metadata.turnkey);
+        }
+        return this.turnkeyWallet;
+    }
+    async getOrganizationId() {
+        const { metadata } = this;
+        const organizationId = metadata?.turnkey?.organizationId ||
+            metadata?.turnkey?.defaultOrganizationId;
+        if (!organizationId) {
+            throw new exceptions_1.WalletException(new Error('Organization ID is required'));
+        }
+        return organizationId;
+    }
+}
+exports.BaseTurnkeyWalletStrategy = BaseTurnkeyWalletStrategy;

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

@@ -0,0 +1,5 @@
+import { BaseTurnkeyWalletStrategy } from './base.js';
+import { ConcreteEthereumWalletStrategyArgs } from '@injectivelabs/wallet-base';
+export declare class TurnkeyOauthWalletStrategy extends BaseTurnkeyWalletStrategy {
+    constructor(args: ConcreteEthereumWalletStrategyArgs);
+}

package/dist/cjs/strategy/strategy/oauth.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurnkeyOauthWalletStrategy = void 0;
+const base_js_1 = require("./base.js");
+const wallet_base_1 = require("@injectivelabs/wallet-base");
+class TurnkeyOauthWalletStrategy extends base_js_1.BaseTurnkeyWalletStrategy {
+    constructor(args) {
+        super({
+            ...args,
+            provider: wallet_base_1.TurnkeyProvider.Google,
+        });
+    }
+}
+exports.TurnkeyOauthWalletStrategy = TurnkeyOauthWalletStrategy;

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

@@ -0,0 +1,5 @@
+import { BaseTurnkeyWalletStrategy } from './base.js';
+import { ConcreteEthereumWalletStrategyArgs } from '@injectivelabs/wallet-base';
+export declare class TurnkeyOtpWalletStrategy extends BaseTurnkeyWalletStrategy {
+    constructor(args: ConcreteEthereumWalletStrategyArgs);
+}

package/dist/cjs/strategy/strategy/otp.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurnkeyOtpWalletStrategy = void 0;
+const base_js_1 = require("./base.js");
+const wallet_base_1 = require("@injectivelabs/wallet-base");
+class TurnkeyOtpWalletStrategy extends base_js_1.BaseTurnkeyWalletStrategy {
+    constructor(args) {
+        super({
+            ...args,
+            provider: wallet_base_1.TurnkeyProvider.Email,
+        });
+    }
+}
+exports.TurnkeyOtpWalletStrategy = TurnkeyOtpWalletStrategy;

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

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

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurnkeyOauthWallet = void 0;
+const exceptions_1 = require("@injectivelabs/exceptions");
+const sdk_ts_1 = require("@injectivelabs/sdk-ts");
+const consts_js_1 = require("../consts.js");
+class TurnkeyOauthWallet {
+    static async generateOAuthNonce(iframeClient) {
+        try {
+            const targetPublicKey = iframeClient.iframePublicKey;
+            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, iframeClient } = args;
+        const path = args.oauthLoginPath || consts_js_1.TURNKEY_OAUTH_PATH;
+        try {
+            const targetPublicKey = iframeClient.iframePublicKey;
+            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,
+            });
+            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;