@injectivelabs/wallet-turnkey 1.15.10

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

@@ -0,0 +1,64 @@
+"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, iframeClient } = args;
+        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(args.otpInitPath || consts_js_1.TURNKEY_OTP_INIT_PATH, {
+                targetPublicKey,
+                email: args.email,
+                suborgId: args.subOrgId,
+                invalidateExistingSessions: args.invalidateExistingSessions,
+            });
+            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, iframeClient } = args;
+        try {
+            const organizationId = args.organizationId;
+            const emailOTPId = args.emailOTPId;
+            const targetPublicKey = iframeClient.iframePublicKey;
+            const otpVerifyPath = args.otpVerifyPath || consts_js_1.TURNKEY_OTP_VERIFY_PATH;
+            if (!targetPublicKey) {
+                throw new exceptions_1.WalletException(new Error('Target public key not found'));
+            }
+            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, {
+                targetPublicKey,
+                otpId: emailOTPId,
+                otpCode: args.otpCode,
+                suborgID: organizationId,
+            });
+            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,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("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;
+}

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

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurnkeyWallet = void 0;
+const sdk_browser_1 = require("@turnkey/sdk-browser");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const wallet_base_1 = require("@injectivelabs/wallet-base");
+const sdk_ts_1 = require("@injectivelabs/sdk-ts");
+const utils_1 = require("@injectivelabs/utils");
+const viem_1 = require("@turnkey/viem");
+const types_js_1 = require("../types.js");
+class TurnkeyWallet {
+    iframeClient;
+    turnkey;
+    client;
+    metadata;
+    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, iframeClient } = await createTurnkeyIFrame(metadata);
+        return {
+            turnkey,
+            iframeClient,
+        };
+    }
+    async getTurnkey() {
+        if (!this.iframeClient) {
+            await this.initFrame();
+        }
+        if (!this.turnkey) {
+            this.turnkey = new sdk_browser_1.Turnkey(this.metadata);
+        }
+        return this.turnkey;
+    }
+    async getIframeClient() {
+        if (!this.iframeClient) {
+            await this.initFrame();
+        }
+        if (!this.iframeClient) {
+            throw new exceptions_1.WalletException(new Error('Iframe client not initialized'));
+        }
+        return this.iframeClient;
+    }
+    async getSession(existingCredentialBundle) {
+        const { metadata } = this;
+        const iframeClient = await this.getIframeClient();
+        const turnkey = await this.getTurnkey();
+        const currentSession = await turnkey.getSession();
+        const organizationId = currentSession?.organizationId || metadata.defaultOrganizationId;
+        const credentialBundle = existingCredentialBundle || currentSession?.token;
+        if (!credentialBundle) {
+            return {
+                session: undefined,
+                organizationId,
+            };
+        }
+        try {
+            const loginResult = await iframeClient.injectCredentialBundle(credentialBundle);
+            // If there is no session, we want to force a refresh to enable to browser SDK to handle key storage and proper session management.
+            await iframeClient.refreshSession({
+                sessionType: sdk_browser_1.SessionType.READ_WRITE,
+                targetPublicKey: iframeClient.iframePublicKey,
+                expirationSeconds: '900',
+            });
+            const [session, user] = await Promise.all([
+                turnkey.getSession(),
+                iframeClient.getWhoami(),
+            ]);
+            const actualOrganizationId = user?.organizationId || session?.organizationId || organizationId;
+            if (!loginResult) {
+                return {
+                    session: undefined,
+                    organizationId: actualOrganizationId,
+                };
+            }
+            return {
+                session,
+                organizationId: actualOrganizationId,
+            };
+        }
+        catch (e) {
+            throw new exceptions_1.WalletException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: 'turnkey-wallet-get-session',
+            });
+        }
+    }
+    async getAccounts() {
+        const iframeClient = await this.getIframeClient();
+        if (!this.metadata.organizationId) {
+            return [];
+        }
+        try {
+            const response = await iframeClient.getWallets({
+                organizationId: this.metadata.organizationId,
+            });
+            const accounts = await Promise.allSettled(response.wallets.map((wallet) => iframeClient.getWalletAccounts({
+                walletId: wallet.walletId,
+                organizationId: this.metadata.organizationId,
+            })));
+            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, organizationId) {
+        const { accountMap } = this;
+        const iframeClient = await this.getIframeClient();
+        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'));
+        }
+        iframeClient.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: iframeClient,
+        });
+        this.accountMap[address] = turnkeyAccount;
+        return turnkeyAccount;
+    }
+    async injectAndRefresh(credentialBundle) {
+        const iframeClient = await this.getIframeClient();
+        await iframeClient.injectCredentialBundle(credentialBundle);
+        await iframeClient.refreshSession({
+            sessionType: sdk_browser_1.SessionType.READ_WRITE,
+            targetPublicKey: iframeClient.iframePublicKey,
+            expirationSeconds: '900',
+        });
+        return;
+    }
+    async initFrame() {
+        const { metadata } = this;
+        const { turnkey, iframeClient } = await createTurnkeyIFrame(metadata);
+        this.turnkey = turnkey;
+        this.iframeClient = iframeClient;
+    }
+}
+exports.TurnkeyWallet = TurnkeyWallet;
+async function createTurnkeyIFrame(metadata) {
+    const turnkey = new sdk_browser_1.Turnkey(metadata);
+    const turnkeyAuthIframeElementId = metadata.iframeElementId || 'turnkey-auth-iframe-element-id';
+    if (!metadata.iframeContainerId) {
+        throw new exceptions_1.GeneralException(new Error('iframeContainerId is required'));
+    }
+    if (!turnkey) {
+        throw new exceptions_1.GeneralException(new Error('Turnkey is not initialized'));
+    }
+    const iframe = document.getElementById(metadata.iframeContainerId);
+    if (!iframe) {
+        throw new exceptions_1.GeneralException(new Error('iframe is null'));
+    }
+    const existingIframeClient = document.getElementById(turnkeyAuthIframeElementId);
+    if (existingIframeClient) {
+        existingIframeClient.remove();
+    }
+    const iframeClient = await turnkey.iframeClient({
+        iframeContainer: iframe,
+        iframeElementId: turnkeyAuthIframeElementId,
+        iframeUrl: metadata?.iframeUrl || 'https://auth.turnkey.com',
+    });
+    return {
+        turnkey,
+        iframeClient,
+    };
+}

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

@@ -0,0 +1,26 @@
+export declare enum TurnkeyErrorCodes {
+    UserLoggedOut = 7
+}
+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 = {
+    credentialBundle: string;
+};
+export type TurnkeyOauthLoginResponse = {
+    organizationId: string;
+    credentialBundle: string;
+    message: string;
+};

package/dist/cjs/strategy/types.js

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

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

@@ -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/esm/index.js

@@ -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/esm/package.json

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

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

@@ -0,0 +1,4 @@
+export const TURNKEY_OAUTH_PATH = 'turnkey/oauth';
+export const TURNKEY_OTP_PATH = 'turnkey/otp';
+export const TURNKEY_OTP_INIT_PATH = `${TURNKEY_OTP_PATH}/init`;
+export const TURNKEY_OTP_VERIFY_PATH = `${TURNKEY_OTP_PATH}/verify`;

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