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

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurnkeyOtpWallet = void 0;
+const exceptions_1 = require("@injectivelabs/exceptions");
+const consts_js_1 = require("../consts.js");
+class TurnkeyOtpWallet {
+    static async initEmailOTP(args) {
+        const { client, indexedDbClient, expirationSeconds } = args;
+        try {
+            await indexedDbClient.resetKeyPair();
+            let publicKey = await indexedDbClient.getPublicKey();
+            if (!publicKey) {
+                throw new exceptions_1.WalletException(new Error('Public key not found'));
+            }
+            // client.$post is undefined, resorting to this for now
+            const response = await client.post(args.otpInitPath || consts_js_1.TURNKEY_OTP_INIT_PATH, {
+                targetPublicKey: publicKey,
+                email: args.email,
+                suborgId: args.subOrgId,
+                invalidateExistingSessions: args.invalidateExistingSessions,
+                isUsingIndexedDB: true,
+                expirationSeconds: expirationSeconds || consts_js_1.DEFAULT_TURNKEY_REFRESH_SECONDS,
+            });
+            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-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 || consts_js_1.TURNKEY_OTP_VERIFY_PATH;
+            if (!emailOTPId) {
+                throw new exceptions_1.WalletException(new Error('Email OTP ID is required'));
+            }
+            if (!organizationId) {
+                throw new exceptions_1.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 || 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-confirm-email-otp',
+            });
+        }
+    }
+}
+exports.TurnkeyOtpWallet = TurnkeyOtpWallet;

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

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

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurnkeyWallet = void 0;
+const viem_1 = require("@turnkey/viem");
+const utils_1 = require("@injectivelabs/utils");
+const sdk_ts_1 = require("@injectivelabs/sdk-ts");
+const sdk_browser_1 = require("@turnkey/sdk-browser");
+const wallet_base_1 = require("@injectivelabs/wallet-base");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const otp_js_1 = require("./otp.js");
+const types_js_1 = require("../types.js");
+const oauth_js_1 = require("./oauth.js");
+const utils_js_1 = require("../../utils.js");
+const consts_js_1 = require("../consts.js");
+class TurnkeyWallet {
+    otpId;
+    turnkey;
+    userOrganizationId;
+    client;
+    metadata;
+    indexedDbClient;
+    accountMap = {};
+    setMetadata(metadata) {
+        this.metadata = { ...this.metadata, ...metadata };
+    }
+    constructor(metadata) {
+        this.metadata = metadata;
+        this.client = new utils_1.HttpRestClient(metadata.apiServerEndpoint);
+    }
+    static async getTurnkeyInstance(metadata) {
+        const { turnkey, indexedDbClient } = await createTurnkeyClient(metadata);
+        return {
+            turnkey,
+            indexedDbClient,
+        };
+    }
+    async getTurnkey() {
+        if (!this.indexedDbClient) {
+            await this.initClient();
+        }
+        if (!this.turnkey) {
+            this.turnkey = new sdk_browser_1.Turnkey(this.metadata);
+        }
+        return this.turnkey;
+    }
+    async getIndexedDbClient() {
+        if (!this.indexedDbClient) {
+            await this.initClient();
+        }
+        if (!this.indexedDbClient) {
+            throw new exceptions_1.WalletException(new Error('Indexed DB client not initialized'));
+        }
+        return this.indexedDbClient;
+    }
+    async getSession(existingCredentialBundle) {
+        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 actualOrganizationId = user?.organizationId || session?.organizationId || organizationId;
+            if (!user) {
+                return {
+                    session: undefined,
+                    organizationId: actualOrganizationId,
+                };
+            }
+            this.userOrganizationId = actualOrganizationId;
+            return {
+                session,
+                organizationId: actualOrganizationId,
+            };
+        }
+        catch {
+            throw new exceptions_1.TurnkeyWalletSessionException(new Error('Session expired. Please login again.'));
+        }
+    }
+    async getAccounts() {
+        const indexedDbClient = await this.getIndexedDbClient();
+        if (!this.userOrganizationId) {
+            return [];
+        }
+        try {
+            const response = await indexedDbClient.getWallets({
+                organizationId: this.userOrganizationId,
+            });
+            const accounts = await Promise.allSettled(response.wallets.map((wallet) => indexedDbClient.getWalletAccounts({
+                walletId: wallet.walletId,
+                organizationId: this.userOrganizationId,
+            })));
+            const filteredAccounts = accounts
+                .filter((account) => account.status === 'fulfilled')
+                .flatMap((result) => result.value?.accounts)
+                .filter((wa) => !!wa &&
+                wa.addressFormat === 'ADDRESS_FORMAT_ETHEREUM' &&
+                !!wa.address);
+            return filteredAccounts.map((account) => (0, sdk_ts_1.getInjectiveAddress)(account.address));
+        }
+        catch (e) {
+            if (e.code === types_js_1.TurnkeyErrorCodes.UserLoggedOut) {
+                throw new exceptions_1.WalletException(new Error('User is not logged in'), {
+                    code: exceptions_1.UnspecifiedErrorCode,
+                    type: exceptions_1.ErrorType.WalletError,
+                    contextModule: wallet_base_1.WalletAction.GetAccounts,
+                    contextCode: types_js_1.TurnkeyErrorCodes.UserLoggedOut,
+                });
+            }
+            throw new exceptions_1.WalletException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: 'turnkey-wallet-get-accounts',
+            });
+        }
+    }
+    async getOrCreateAndGetAccount(address) {
+        const { accountMap } = this;
+        const indexedDbClient = await this.getIndexedDbClient();
+        const organizationId = this.userOrganizationId;
+        if (accountMap[address] || accountMap[address.toLowerCase()]) {
+            return accountMap[address] || accountMap[address.toLowerCase()];
+        }
+        if (!organizationId) {
+            throw new exceptions_1.WalletException(new Error('Organization ID is required'));
+        }
+        indexedDbClient.config.organizationId = organizationId;
+        if (!address) {
+            throw new exceptions_1.WalletException(new Error('Account address not found'));
+        }
+        const turnkeyAccount = await (0, viem_1.createAccount)({
+            organizationId,
+            signWith: address,
+            client: indexedDbClient,
+        });
+        this.accountMap[address] = turnkeyAccount;
+        return turnkeyAccount;
+    }
+    async initOTP(email) {
+        const indexedDbClient = await this.getIndexedDbClient();
+        const result = await otp_js_1.TurnkeyOtpWallet.initEmailOTP({
+            client: this.client,
+            indexedDbClient,
+            email,
+            otpInitPath: this.metadata.otpInitPath || consts_js_1.TURNKEY_OTP_INIT_PATH,
+        });
+        if (!result || !result.otpId) {
+            throw new exceptions_1.WalletException(new Error('Failed to initialize OTP'));
+        }
+        if (result?.organizationId) {
+            this.userOrganizationId = result.organizationId;
+        }
+        if (result?.otpId) {
+            this.otpId = result.otpId;
+        }
+        return result;
+    }
+    async confirmOTP(otpCode) {
+        const indexedDbClient = await this.getIndexedDbClient();
+        const targetPublicKey = await indexedDbClient.getPublicKey();
+        if (!this.otpId) {
+            throw new exceptions_1.WalletException(new Error('OTP ID is required'));
+        }
+        if (!targetPublicKey) {
+            throw new exceptions_1.WalletException(new Error('Target public key not found'));
+        }
+        if (!this.userOrganizationId) {
+            throw new exceptions_1.WalletException(new Error('Organization ID is required'));
+        }
+        const result = await otp_js_1.TurnkeyOtpWallet.confirmEmailOTP({
+            otpCode,
+            client: this.client,
+            emailOTPId: this.otpId,
+            organizationId: this.userOrganizationId,
+            targetPublicKey,
+            otpVerifyPath: this.metadata.otpVerifyPath || consts_js_1.TURNKEY_OTP_VERIFY_PATH,
+        });
+        if (!result || !result.session) {
+            throw new exceptions_1.WalletException(new Error('Failed to confirm OTP'));
+        }
+        await indexedDbClient.loginWithSession(result.session);
+        this.userOrganizationId = result.organizationId;
+        return result;
+    }
+    async initOAuth(provider) {
+        if (provider === wallet_base_1.TurnkeyProvider.Apple) {
+            throw new exceptions_1.WalletException(new Error('Apple sign in option is currently not supported'));
+        }
+        const indexedDbClient = await this.getIndexedDbClient();
+        const nonce = await oauth_js_1.TurnkeyOauthWallet.generateOAuthNonce(indexedDbClient);
+        if (!this.metadata?.googleClientId || !this.metadata?.googleRedirectUri) {
+            throw new exceptions_1.WalletException(new Error('googleClientId and googleRedirectUri are required'));
+        }
+        return (0, utils_js_1.generateGoogleUrl)({
+            nonce,
+            clientId: this.metadata.googleClientId,
+            redirectUri: this.metadata.googleRedirectUri,
+        });
+    }
+    async confirmOAuth(provider, oidcToken) {
+        if (provider === wallet_base_1.TurnkeyProvider.Apple) {
+            throw new exceptions_1.WalletException(new Error('Apple sign in option is currently not supported'));
+        }
+        const indexedDbClient = await this.getIndexedDbClient();
+        const oauthResult = await oauth_js_1.TurnkeyOauthWallet.oauthLogin({
+            oidcToken,
+            indexedDbClient,
+            client: this.client,
+            providerName: provider.toString(),
+            oauthLoginPath: this.metadata.oauthLoginPath || consts_js_1.TURNKEY_OAUTH_PATH,
+        });
+        if (!oauthResult || !oauthResult.credentialBundle) {
+            throw new exceptions_1.WalletException(new Error('Unexpected OAuth result'));
+        }
+        await indexedDbClient.loginWithSession(oauthResult.credentialBundle);
+        this.userOrganizationId = oauthResult.organizationId;
+        return oauthResult.credentialBundle;
+    }
+    async refreshSession() {
+        const session = await this.getSession();
+        const indexedDbClient = await this.getIndexedDbClient();
+        if (session.session?.token) {
+            await indexedDbClient.refreshSession({
+                sessionType: sdk_browser_1.SessionType.READ_WRITE,
+                expirationSeconds: this.metadata.expirationSeconds,
+            });
+            this.userOrganizationId = session.organizationId;
+            return session.session.token;
+        }
+        throw new exceptions_1.TurnkeyWalletSessionException(new Error('Session expired. Please login again.'));
+    }
+    async initClient() {
+        const { metadata } = this;
+        const { turnkey, indexedDbClient } = await createTurnkeyClient(metadata);
+        this.turnkey = turnkey;
+        this.indexedDbClient = indexedDbClient;
+        return { turnkey, indexedDbClient };
+    }
+}
+exports.TurnkeyWallet = TurnkeyWallet;
+async function createTurnkeyClient(metadata) {
+    const turnkey = new sdk_browser_1.Turnkey(metadata);
+    const indexedDbClient = await turnkey.indexedDbClient();
+    await indexedDbClient.init();
+    if (!turnkey) {
+        throw new exceptions_1.GeneralException(new Error('Turnkey is not initialized'));
+    }
+    return {
+        turnkey,
+        indexedDbClient,
+    };
+}

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

@@ -0,0 +1,28 @@
+export declare const TurnkeyErrorCodes: {
+    readonly UserLoggedOut: 7;
+};
+export type TurnkeyErrorCodes = (typeof TurnkeyErrorCodes)[keyof typeof TurnkeyErrorCodes];
+export type TurnkeyOAuthArgs = {
+    provider: 'google';
+    oidcToken: string;
+    oauthLoginEndpoint: string;
+};
+export type TurnkeyEmailArgs = {
+    provider: 'email';
+    email: string;
+    initEmailOTPEndpoint: string;
+};
+export type TurnkeyEnableArgs = TurnkeyOAuthArgs | TurnkeyEmailArgs;
+export type TurnkeyOTPCredentialsResponse = {
+    otpId: string;
+    organizationId: string;
+};
+export type TurnkeyConfirmEmailOTPResponse = {
+    session: string;
+    organizationId: string;
+};
+export type TurnkeyOauthLoginResponse = {
+    organizationId: string;
+    credentialBundle: string;
+    message: string;
+};

package/dist/cjs/strategy/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurnkeyErrorCodes = void 0;
+exports.TurnkeyErrorCodes = {
+    UserLoggedOut: 7,
+};

package/dist/cjs/utils.d.ts

@@ -0,0 +1,7 @@
+export declare function generateGoogleUrl({ nonce, clientId, redirectUri, scope, prompt, }: {
+    nonce: string;
+    clientId: string;
+    redirectUri: string;
+    scope?: string;
+    prompt?: string;
+}): string;

package/dist/cjs/utils.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGoogleUrl = generateGoogleUrl;
+function generateGoogleUrl({ nonce, clientId, redirectUri, scope = 'openid profile email', prompt = 'consent', }) {
+    if (!clientId) {
+        throw new Error('Google client ID not found');
+    }
+    const responseType = 'id_token';
+    return `https://accounts.google.com/o/oauth2/v2/auth?prompt=${prompt}&client_id=${clientId}&redirect_uri=${redirectUri}&response_type=${responseType}&scope=${scope}&nonce=${nonce}`;
+}

package/dist/esm/index.d.ts

@@ -1,92 +1,3 @@
-import { AminoSignResponse, DirectSignResponse, TxRaw } from "@injectivelabs/sdk-ts";
-import { HttpRestClient } from "@injectivelabs/utils";
-import { BaseConcreteStrategy, ConcreteEvmWalletStrategyArgs, ConcreteWalletStrategy, Eip1193Provider, SendTransactionOptions, StdSignDoc, TurnkeyMetadata, TurnkeyProvider, WalletDeviceType, WalletMetadata, WalletStrategyEvmOptions } from "@injectivelabs/wallet-base";
-import { createAccount } from "@turnkey/viem";
-import * as _turnkey_sdk_browser0 from "@turnkey/sdk-browser";
-import { Turnkey, TurnkeyIndexedDbClient } from "@turnkey/sdk-browser";
-import { AccountAddress, EvmChainId } from "@injectivelabs/ts-types";
-
-//#region src/strategy/strategy.d.ts
-declare class TurnkeyWalletStrategy extends BaseConcreteStrategy implements ConcreteWalletStrategy {
-  turnkeyWallet?: TurnkeyWallet$1;
-  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$1>(): Promise<TurnkeyWallet$1>;
-  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>;
-}
-//#endregion
-//#region src/strategy/types.d.ts
-type TurnkeyOTPCredentialsResponse = {
-  otpId: string;
-  organizationId: string;
-};
-type TurnkeyConfirmEmailOTPResponse = {
-  session: string;
-  organizationId: string;
-};
-//#endregion
-//#region src/strategy/turnkey/turnkey.d.ts
-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: _turnkey_sdk_browser0.Session | undefined;
-    organizationId: string;
-  }>;
-  getAccounts(): Promise<string[]>;
-  getOrCreateAndGetAccount(address: string): Promise<ReturnType<typeof createAccount>>;
-  initOTP(email: string): Promise<TurnkeyOTPCredentialsResponse>;
-  confirmOTP(otpCode: string): Promise<TurnkeyConfirmEmailOTPResponse>;
-  initOAuth(provider: TurnkeyProvider): Promise<string>;
-  confirmOAuth(provider: TurnkeyProvider, oidcToken: string): Promise<string>;
-  refreshSession(): Promise<string>;
-  private initClient;
-}
-//#endregion
-export { TurnkeyWallet, TurnkeyWalletStrategy };
+export { TurnkeyWalletStrategy } from './strategy/strategy.js';
+export * from './strategy/strategy.js';
+export * from './strategy/turnkey/turnkey.js';