@injectivelabs/wallet-turnkey 1.16.37 → 1.16.38-alpha.0

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

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

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

@@ -1,23 +0,0 @@
-import { type TurnkeyConfirmEmailOTPResponse, type TurnkeyOTPCredentialsResponse } from './../types.js';
-import type { HttpRestClient } from '@injectivelabs/utils';
-import type { TurnkeyIndexedDbClient } from '@turnkey/sdk-browser';
-export declare class TurnkeyOtpWallet {
-    static initEmailOTP(args: {
-        email: string;
-        subOrgId?: string;
-        otpInitPath?: string;
-        client: HttpRestClient;
-        indexedDbClient: TurnkeyIndexedDbClient;
-        invalidateExistingSessions?: boolean;
-        expirationSeconds?: number;
-    }): Promise<TurnkeyOTPCredentialsResponse | undefined>;
-    static confirmEmailOTP(args: {
-        otpCode: string;
-        emailOTPId: string;
-        client: HttpRestClient;
-        targetPublicKey: string;
-        organizationId: string;
-        otpVerifyPath?: string;
-        expirationSeconds?: number;
-    }): Promise<TurnkeyConfirmEmailOTPResponse | undefined>;
-}

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

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

@@ -1,35 +0,0 @@
-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

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

@@ -1,28 +0,0 @@
-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

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

package/dist/cjs/utils.d.ts

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

@@ -1,10 +0,0 @@
-"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/strategy/Eip1193Provider.d.ts

@@ -1,3 +0,0 @@
-import type { LocalAccount } from 'viem';
-import type { Eip1193Provider } from '@injectivelabs/wallet-base';
-export declare const getEip1193ProviderForTurnkey: (account: LocalAccount, chainId: string) => Promise<Eip1193Provider>;

package/dist/esm/strategy/Eip1193Provider.js

@@ -1,127 +0,0 @@
-import { getEvmChainConfig, getViemPublicClient, getViemWalletClient, } from '@injectivelabs/wallet-base';
-export const getEip1193ProviderForTurnkey = async (account, chainId) => {
-    const provider = new CustomEip1193Provider({
-        chainId: parseInt(chainId, 16),
-        signTypedData: account.signTypedData.bind(account),
-        signMessage: account.signMessage.bind(account),
-        signTransaction: account.signTransaction.bind(account),
-        account,
-        address: account.address,
-    });
-    return provider;
-};
-class CustomEip1193Provider {
-    chainId;
-    signTypedData;
-    signMessage;
-    signTransaction;
-    account;
-    address;
-    constructor(args) {
-        this.chainId = args.chainId ?? 1;
-        this.signTypedData = args.signTypedData;
-        this.signMessage = args.signMessage;
-        this.account = args.account;
-        this.address = args.address;
-        this.signTransaction = args.signTransaction;
-    }
-    async requestAccounts() {
-        return [this.address];
-    }
-    getClient() {
-        return getViemWalletClient({
-            chainId: this.chainId,
-            account: this.account,
-        });
-    }
-    getChain() {
-        return getEvmChainConfig(this.chainId);
-    }
-    on(_event, _listener) {
-        throw new Error('Not implemented');
-    }
-    removeListener(..._args) {
-        throw new Error('Not implemented!');
-    }
-    async request(args) {
-        if (args.method === 'eth_requestAccounts') {
-            return this.requestAccounts();
-        }
-        if (args.method === 'eth_signTypedData') {
-            if (!args.params) {
-                throw new Error('params is required');
-            }
-            return this.signTypedData(args.params[0]);
-        }
-        if (args.method === 'eth_signMessage') {
-            if (!args.params) {
-                throw new Error('params is required');
-            }
-            return this.signMessage(args.params[0]);
-        }
-        if (args.method === 'eth_chainId') {
-            return this.chainId;
-        }
-        if (args.method === 'wallet_switchEthereumChain') {
-            if (!args.params) {
-                throw new Error('params is required');
-            }
-            const chainId = String(args.params[0].chainId).replace('0x', '');
-            this.chainId = parseInt(chainId, 16);
-            return true;
-        }
-        if (args.method === 'eth_sendTransaction') {
-            if (!args.params) {
-                throw new Error('params is required');
-            }
-            const accountClient = getViemWalletClient({
-                chainId: this.chainId,
-                account: this.account,
-            });
-            const client = this.getClient();
-            const parseHexValue = (value) => {
-                if (typeof value === 'string') {
-                    const hexValue = value.startsWith('0x') ? value : `0x${value}`;
-                    return BigInt(hexValue);
-                }
-                return BigInt(value);
-            };
-            const txData = args.params[0];
-            const processedTransaction = { ...txData };
-            const hexFields = [
-                'value',
-                'gas',
-                'gasLimit',
-                'gasPrice',
-                'maxFeePerGas',
-                'maxPriorityFeePerGas',
-            ];
-            for (const field of hexFields) {
-                if (processedTransaction[field] !== undefined) {
-                    processedTransaction[field] = parseHexValue(processedTransaction[field]);
-                }
-            }
-            const preparedTransaction = await accountClient.prepareTransactionRequest(processedTransaction);
-            const signedTransaction = await this.signTransaction(preparedTransaction);
-            const tx = await client.sendRawTransaction({
-                serializedTransaction: signedTransaction,
-            });
-            return tx;
-        }
-        if (args.method === 'eth_getTransactionCount') {
-            if (!args.params) {
-                throw new Error('params is required');
-            }
-            const client = getViemPublicClient(this.chainId);
-            const count = await client.getTransactionCount({
-                address: this.address,
-                blockTag: 'pending',
-            });
-            return `0x${count.toString(16)}`;
-        }
-        return this.getClient().request({
-            method: args.method,
-            params: args.params,
-        });
-    }
-}

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

@@ -1,13 +0,0 @@
-export declare const TURNKEY_OAUTH_PATH = "turnkey/oauth";
-export declare const TURNKEY_OTP_PATH = "turnkey/otp";
-export declare const TURNKEY_OTP_INIT_PATH = "turnkey/otp/init";
-export declare const TURNKEY_OTP_VERIFY_PATH = "turnkey/otp/verify";
-export declare const DEFAULT_TURNKEY_REFRESH_SECONDS = "86400";
-export declare const DEFAULT_EVM_CHAIN_CONFIG: {
-    name: string;
-    nativeCurrency: {
-        name: string;
-        symbol: string;
-        decimals: number;
-    };
-};

package/dist/esm/strategy/consts.js

@@ -1,13 +0,0 @@
-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`;
-export const DEFAULT_TURNKEY_REFRESH_SECONDS = '86400';
-export const DEFAULT_EVM_CHAIN_CONFIG = {
-    name: 'Injective',
-    nativeCurrency: {
-        name: 'Injective',
-        symbol: 'INJ',
-        decimals: 18,
-    },
-};