@injectivelabs/wallet-turnkey 1.15.10

package/dist/esm/strategy/strategy/base.js

@@ -0,0 +1,323 @@
+/* eslint-disable class-methods-use-this */
+import { ErrorType, WalletException, UnspecifiedErrorCode, TransactionException, CosmosWalletException, } from '@injectivelabs/exceptions';
+import { TxGrpcApi, } from '@injectivelabs/sdk-ts';
+import { HttpRestClient } from '@injectivelabs/utils';
+import { WalletAction, TurnkeyProvider, WalletDeviceType, BaseConcreteStrategy, } from '@injectivelabs/wallet-base';
+import { TurnkeyWallet } from '../turnkey/turnkey.js';
+import { TurnkeyErrorCodes } from '../types.js';
+import { TurnkeyOtpWallet } from '../turnkey/otp.js';
+import { TurnkeyOauthWallet } from '../turnkey/oauth.js';
+import { SessionType } from '@turnkey/sdk-browser';
+import { getAddress } from 'viem';
+import { generateGoogleUrl } from '../../utils.js';
+export class BaseTurnkeyWalletStrategy extends BaseConcreteStrategy {
+    turnkeyWallet;
+    turnkeyProvider;
+    client;
+    constructor(args) {
+        super(args);
+        this.turnkeyProvider = args.provider;
+        const endpoint = args.apiServerEndpoint || this.metadata?.turnkey?.apiServerEndpoint;
+        if (!endpoint) {
+            throw new WalletException(new Error('apiServerEndpoint is required'));
+        }
+        this.client = new HttpRestClient(endpoint);
+    }
+    async getWalletDeviceType() {
+        return Promise.resolve(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 === TurnkeyProvider.Email) {
+                if (!this.metadata?.turnkey?.otpId) {
+                    throw new WalletException(new Error('OTP ID is required'));
+                }
+                if (!this.metadata?.turnkey?.otpCode) {
+                    throw new WalletException(new Error('OTP code is required'));
+                }
+                const result = await 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 WalletException(new Error('Oidc token is required'));
+                }
+                const result = await 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 === TurnkeyErrorCodes.UserLoggedOut) {
+                await this.disconnect();
+                throw e;
+            }
+            throw new WalletException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: 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: SessionType.READ_WRITE,
+                targetPublicKey: iframeClient.iframePublicKey,
+                expirationSeconds: '900',
+            });
+            return session.session.token;
+        }
+        if (turnkeyProvider === TurnkeyProvider.Email) {
+            if (!metadata?.turnkey?.email) {
+                throw new WalletException(new Error('Email is required'));
+            }
+            const result = await 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 ([TurnkeyProvider.Google, TurnkeyProvider.Apple].includes(turnkeyProvider)) {
+            if (metadata?.turnkey?.oidcToken) {
+                const oauthResult = await 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 WalletException(new Error('Oauth result not found'));
+            }
+            else {
+                const nonce = await TurnkeyOauthWallet.generateOAuthNonce(iframeClient);
+                if (!metadata?.turnkey?.googleClientId ||
+                    !metadata?.turnkey?.googleRedirectUri) {
+                    throw new WalletException(new Error('googleClientId and googleRedirectUri are required'));
+                }
+                if (turnkeyProvider === TurnkeyProvider.Google) {
+                    return 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 WalletException(new Error('sendEthereumTransaction is not supported. Turnkey only supports sending cosmos transactions'), {
+            code: UnspecifiedErrorCode,
+            context: WalletAction.SendEthereumTransaction,
+        });
+    }
+    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();
+        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 = getAddress(address);
+        const account = await turnkeyWallet.getOrCreateAndGetAccount(checksumAddress, organizationId);
+        if (!account) {
+            throw new WalletException(new Error('Turnkey account not found'));
+        }
+        let parsedData;
+        try {
+            parsedData = JSON.parse(eip712json);
+        }
+        catch (e) {
+            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;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    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 getEthereumTransactionReceipt(_txHash) {
+        throw new CosmosWalletException(new Error('getEthereumTransactionReceipt is not supported on Turnkey'), {
+            code: UnspecifiedErrorCode,
+            type: ErrorType.WalletError,
+            context: WalletAction.GetEthereumTransactionReceipt,
+        });
+    }
+    // eslint-disable-next-line class-methods-use-this
+    async getPubKey() {
+        throw new 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 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'));
+            }
+            if (!metadata.turnkey.defaultOrganizationId) {
+                throw new WalletException(new Error('Turnkey defaultOrganizationId is required'));
+            }
+            this.turnkeyWallet = new TurnkeyWallet(metadata.turnkey);
+        }
+        return this.turnkeyWallet;
+    }
+    async getOrganizationId() {
+        const { metadata } = this;
+        const organizationId = metadata?.turnkey?.organizationId ||
+            metadata?.turnkey?.defaultOrganizationId;
+        if (!organizationId) {
+            throw new WalletException(new Error('Organization ID is required'));
+        }
+        return organizationId;
+    }
+}

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

@@ -0,0 +1,10 @@
+import { BaseTurnkeyWalletStrategy } from './base.js';
+import { TurnkeyProvider, } from '@injectivelabs/wallet-base';
+export class TurnkeyOauthWalletStrategy extends BaseTurnkeyWalletStrategy {
+    constructor(args) {
+        super({
+            ...args,
+            provider: TurnkeyProvider.Google,
+        });
+    }
+}

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

@@ -0,0 +1,10 @@
+import { BaseTurnkeyWalletStrategy } from './base.js';
+import { TurnkeyProvider } from '@injectivelabs/wallet-base';
+export class TurnkeyOtpWalletStrategy extends BaseTurnkeyWalletStrategy {
+    constructor(args) {
+        super({
+            ...args,
+            provider: TurnkeyProvider.Email,
+        });
+    }
+}

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

@@ -0,0 +1,47 @@
+import { ErrorType, WalletException, UnspecifiedErrorCode, } from '@injectivelabs/exceptions';
+import { sha256 } from '@injectivelabs/sdk-ts';
+import { TURNKEY_OAUTH_PATH } from '../consts.js';
+export class TurnkeyOauthWallet {
+    static async generateOAuthNonce(iframeClient) {
+        try {
+            const targetPublicKey = iframeClient.iframePublicKey;
+            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, iframeClient } = args;
+        const path = args.oauthLoginPath || TURNKEY_OAUTH_PATH;
+        try {
+            const targetPublicKey = iframeClient.iframePublicKey;
+            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,
+            });
+            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,21 @@
+import { type TurnkeyIframeClient } from '@turnkey/sdk-browser';
+import { type TurnkeyConfirmEmailOTPResponse, type TurnkeyOTPCredentialsResponse } from './../types.js';
+import { type HttpRestClient } from '@injectivelabs/utils';
+export declare class TurnkeyOtpWallet {
+    static initEmailOTP(args: {
+        email: string;
+        subOrgId?: string;
+        otpInitPath?: string;
+        client: HttpRestClient;
+        iframeClient: TurnkeyIframeClient;
+        invalidateExistingSessions?: boolean;
+    }): Promise<TurnkeyOTPCredentialsResponse | undefined>;
+    static confirmEmailOTP(args: {
+        otpCode: string;
+        emailOTPId?: string;
+        client: HttpRestClient;
+        organizationId?: string;
+        iframeClient: TurnkeyIframeClient;
+        otpVerifyPath?: string;
+    }): Promise<TurnkeyConfirmEmailOTPResponse | undefined>;
+}

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

@@ -0,0 +1,60 @@
+import { ErrorType, WalletException, UnspecifiedErrorCode, } from '@injectivelabs/exceptions';
+import { TURNKEY_OTP_INIT_PATH, TURNKEY_OTP_VERIFY_PATH } from '../consts.js';
+export class TurnkeyOtpWallet {
+    static async initEmailOTP(args) {
+        const { client, iframeClient } = args;
+        try {
+            const targetPublicKey = iframeClient.iframePublicKey;
+            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(args.otpInitPath || TURNKEY_OTP_INIT_PATH, {
+                targetPublicKey,
+                email: args.email,
+                suborgId: args.subOrgId,
+                invalidateExistingSessions: args.invalidateExistingSessions,
+            });
+            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, iframeClient } = args;
+        try {
+            const organizationId = args.organizationId;
+            const emailOTPId = args.emailOTPId;
+            const targetPublicKey = iframeClient.iframePublicKey;
+            const otpVerifyPath = args.otpVerifyPath || TURNKEY_OTP_VERIFY_PATH;
+            if (!targetPublicKey) {
+                throw new WalletException(new Error('Target public key not found'));
+            }
+            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, {
+                targetPublicKey,
+                otpId: emailOTPId,
+                otpCode: args.otpCode,
+                suborgID: organizationId,
+            });
+            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,43 @@
+import { Turnkey, TurnkeyIframeClient } from '@turnkey/sdk-browser';
+import { TurnkeyMetadata } from '@injectivelabs/wallet-base';
+import { HttpRestClient } from '@injectivelabs/utils';
+export declare class TurnkeyWallet {
+    protected iframeClient: TurnkeyIframeClient | undefined;
+    protected turnkey: Turnkey | undefined;
+    protected client: HttpRestClient;
+    private metadata;
+    private accountMap;
+    setMetadata(metadata: Partial<TurnkeyMetadata>): void;
+    constructor(metadata: TurnkeyMetadata);
+    static getTurnkeyInstance(metadata: TurnkeyMetadata): Promise<{
+        turnkey: Turnkey;
+        iframeClient: TurnkeyIframeClient;
+    }>;
+    getTurnkey(): Promise<Turnkey>;
+    getIframeClient(): Promise<TurnkeyIframeClient>;
+    getSession(existingCredentialBundle?: string): Promise<{
+        session: import("@turnkey/sdk-browser").Session | undefined;
+        organizationId: string;
+    }>;
+    getAccounts(): Promise<string[]>;
+    getOrCreateAndGetAccount(address: string, organizationId?: string): Promise<{
+        address: import("abitype").Address;
+        nonceManager?: import("viem").NonceManager | undefined;
+        sign?: ((parameters: {
+            hash: import("viem").Hash;
+        }) => Promise<import("viem").Hex>) | undefined | undefined;
+        signAuthorization?: ((parameters: import("node_modules/viem/_types/types/authorization.js").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
+        signMessage: ({ message }: {
+            message: import("viem").SignableMessage;
+        }) => Promise<import("viem").Hex>;
+        signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+            serializer?: serializer | undefined;
+        } | undefined) => Promise<import("viem").IsNarrowable<import("viem").TransactionSerialized<import("viem").GetTransactionType<transaction>>, import("viem").Hex> extends true ? import("viem").TransactionSerialized<import("viem").GetTransactionType<transaction>> : import("viem").Hex>;
+        signTypedData: <const typedData extends import("abitype").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
+        publicKey: import("viem").Hex;
+        source: string;
+        type: "local";
+    }>;
+    injectAndRefresh(credentialBundle: string): Promise<void>;
+    private initFrame;
+}