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

package/dist/esm/index.js

@@ -1,3 +1,680 @@
-export { TurnkeyWalletStrategy } from './strategy/strategy.js';
-export * from './strategy/strategy.js';
-export * from './strategy/turnkey/turnkey.js';
+import { getAddress } from "viem";
+import { TxGrpcApi, getEthereumAddress, getInjectiveAddress, sha256 } from "@injectivelabs/sdk-ts";
+import { HttpRestClient } from "@injectivelabs/utils";
+import { CosmosWalletException, ErrorType, GeneralException, TransactionException, TurnkeyWalletSessionException, UnspecifiedErrorCode, WalletException } from "@injectivelabs/exceptions";
+import { BaseConcreteStrategy, TurnkeyProvider, WalletAction, WalletDeviceType, getEvmChainConfig, getViemPublicClient, getViemWalletClient } from "@injectivelabs/wallet-base";
+import { createAccount } from "@turnkey/viem";
+import { SessionType, Turnkey } from "@turnkey/sdk-browser";
+
+//#region src/strategy/types.ts
+const TurnkeyErrorCodes = { UserLoggedOut: 7 };
+
+//#endregion
+//#region src/strategy/consts.ts
+const TURNKEY_OAUTH_PATH = "turnkey/oauth";
+const TURNKEY_OTP_PATH = "turnkey/otp";
+const TURNKEY_OTP_INIT_PATH = `${TURNKEY_OTP_PATH}/init`;
+const TURNKEY_OTP_VERIFY_PATH = `${TURNKEY_OTP_PATH}/verify`;
+const DEFAULT_TURNKEY_REFRESH_SECONDS = "86400";
+
+//#endregion
+//#region src/strategy/turnkey/otp.ts
+var TurnkeyOtpWallet = class {
+	static async initEmailOTP(args) {
+		const { client, indexedDbClient, expirationSeconds } = args;
+		try {
+			await indexedDbClient.resetKeyPair();
+			let publicKey = await indexedDbClient.getPublicKey();
+			if (!publicKey) throw new WalletException(/* @__PURE__ */ new Error("Public key not found"));
+			const response = await client.post(args.otpInitPath || TURNKEY_OTP_INIT_PATH, {
+				targetPublicKey: publicKey,
+				email: args.email,
+				suborgId: args.subOrgId,
+				invalidateExistingSessions: args.invalidateExistingSessions,
+				isUsingIndexedDB: true,
+				expirationSeconds: expirationSeconds || DEFAULT_TURNKEY_REFRESH_SECONDS
+			});
+			return response === null || response === void 0 ? void 0 : 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, expirationSeconds, targetPublicKey } = args;
+		try {
+			var _ref;
+			const organizationId = args.organizationId;
+			const emailOTPId = args.emailOTPId;
+			const otpVerifyPath = args.otpVerifyPath || TURNKEY_OTP_VERIFY_PATH;
+			if (!emailOTPId) throw new WalletException(/* @__PURE__ */ new Error("Email OTP ID is required"));
+			if (!organizationId) throw new WalletException(/* @__PURE__ */ new Error("Organization ID is required"));
+			const response = await client.post(otpVerifyPath, {
+				isUsingIndexedDB: true,
+				targetPublicKey,
+				otpId: emailOTPId,
+				otpCode: args.otpCode,
+				suborgID: organizationId,
+				expirationSeconds: (_ref = expirationSeconds || DEFAULT_TURNKEY_REFRESH_SECONDS) === null || _ref === void 0 ? void 0 : _ref.toString()
+			});
+			return response === null || response === void 0 ? void 0 : response.data;
+		} catch (e) {
+			throw new WalletException(new Error(e.message), {
+				code: UnspecifiedErrorCode,
+				type: ErrorType.WalletError,
+				contextModule: "turnkey-confirm-email-otp"
+			});
+		}
+	}
+};
+
+//#endregion
+//#region src/strategy/turnkey/oauth.ts
+var TurnkeyOauthWallet = class {
+	static async generateOAuthNonce(indexedDbClient) {
+		try {
+			await indexedDbClient.resetKeyPair();
+			const targetPublicKey = await indexedDbClient.getPublicKey();
+			if (!targetPublicKey) throw new WalletException(/* @__PURE__ */ 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, indexedDbClient, expirationSeconds } = args;
+		const path = args.oauthLoginPath || TURNKEY_OAUTH_PATH;
+		try {
+			var _ref;
+			const targetPublicKey = await indexedDbClient.getPublicKey();
+			if (!targetPublicKey) throw new WalletException(/* @__PURE__ */ new Error("Target public key not found"));
+			return (await client.post(path, {
+				targetPublicKey,
+				oidcToken: args.oidcToken,
+				providerName: args.providerName,
+				expirationSeconds: (_ref = expirationSeconds || DEFAULT_TURNKEY_REFRESH_SECONDS) === null || _ref === void 0 ? void 0 : _ref.toString()
+			})).data;
+		} catch (e) {
+			throw new WalletException(new Error(e.message), {
+				code: UnspecifiedErrorCode,
+				type: ErrorType.WalletError,
+				contextModule: "turnkey-oauth-login"
+			});
+		}
+	}
+};
+
+//#endregion
+//#region src/utils.ts
+function generateGoogleUrl({ nonce, clientId, redirectUri, scope = "openid profile email", prompt = "consent" }) {
+	if (!clientId) throw new Error("Google client ID not found");
+	return `https://accounts.google.com/o/oauth2/v2/auth?prompt=${prompt}&client_id=${clientId}&redirect_uri=${redirectUri}&response_type=id_token&scope=${scope}&nonce=${nonce}`;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region src/strategy/turnkey/turnkey.ts
+var TurnkeyWallet = class {
+	setMetadata(metadata) {
+		this.metadata = {
+			...this.metadata,
+			...metadata
+		};
+	}
+	constructor(metadata) {
+		_defineProperty(this, "otpId", void 0);
+		_defineProperty(this, "turnkey", void 0);
+		_defineProperty(this, "userOrganizationId", void 0);
+		_defineProperty(this, "client", void 0);
+		_defineProperty(this, "metadata", void 0);
+		_defineProperty(this, "indexedDbClient", void 0);
+		_defineProperty(this, "accountMap", {});
+		this.metadata = metadata;
+		this.client = new 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 Turnkey(this.metadata);
+		return this.turnkey;
+	}
+	async getIndexedDbClient() {
+		if (!this.indexedDbClient) await this.initClient();
+		if (!this.indexedDbClient) throw new WalletException(/* @__PURE__ */ new Error("Indexed DB client not initialized"));
+		return this.indexedDbClient;
+	}
+	async getSession(existingCredentialBundle) {
+		try {
+			const { metadata } = this;
+			const indexedDbClient = await this.getIndexedDbClient();
+			const session = await (await this.getTurnkey()).getSession();
+			const organizationId = (session === null || session === void 0 ? void 0 : session.organizationId) || metadata.defaultOrganizationId;
+			if (!(existingCredentialBundle || (session === null || session === void 0 ? void 0 : session.token))) return {
+				session: void 0,
+				organizationId
+			};
+			const user = await indexedDbClient.getWhoami();
+			const actualOrganizationId = (user === null || user === void 0 ? void 0 : user.organizationId) || (session === null || session === void 0 ? void 0 : session.organizationId) || organizationId;
+			if (!user) return {
+				session: void 0,
+				organizationId: actualOrganizationId
+			};
+			this.userOrganizationId = actualOrganizationId;
+			return {
+				session,
+				organizationId: actualOrganizationId
+			};
+		} catch (_unused) {
+			throw new TurnkeyWalletSessionException(/* @__PURE__ */ 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 });
+			return (await Promise.allSettled(response.wallets.map((wallet) => indexedDbClient.getWalletAccounts({
+				walletId: wallet.walletId,
+				organizationId: this.userOrganizationId
+			})))).filter((account) => account.status === "fulfilled").flatMap((result) => {
+				var _result$value;
+				return (_result$value = result.value) === null || _result$value === void 0 ? void 0 : _result$value.accounts;
+			}).filter((wa) => !!wa && wa.addressFormat === "ADDRESS_FORMAT_ETHEREUM" && !!wa.address).map((account) => getInjectiveAddress(account.address));
+		} catch (e) {
+			if (e.code === TurnkeyErrorCodes.UserLoggedOut) throw new WalletException(/* @__PURE__ */ new Error("User is not logged in"), {
+				code: UnspecifiedErrorCode,
+				type: ErrorType.WalletError,
+				contextModule: WalletAction.GetAccounts,
+				contextCode: TurnkeyErrorCodes.UserLoggedOut
+			});
+			throw new WalletException(new Error(e.message), {
+				code: UnspecifiedErrorCode,
+				type: 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 WalletException(/* @__PURE__ */ new Error("Organization ID is required"));
+		indexedDbClient.config.organizationId = organizationId;
+		if (!address) throw new WalletException(/* @__PURE__ */ new Error("Account address not found"));
+		const turnkeyAccount = await createAccount({
+			organizationId,
+			signWith: address,
+			client: indexedDbClient
+		});
+		this.accountMap[address] = turnkeyAccount;
+		return turnkeyAccount;
+	}
+	async initOTP(email) {
+		const indexedDbClient = await this.getIndexedDbClient();
+		const result = await TurnkeyOtpWallet.initEmailOTP({
+			client: this.client,
+			indexedDbClient,
+			email,
+			otpInitPath: this.metadata.otpInitPath || TURNKEY_OTP_INIT_PATH
+		});
+		if (!result || !result.otpId) throw new WalletException(/* @__PURE__ */ new Error("Failed to initialize OTP"));
+		if (result === null || result === void 0 ? void 0 : result.organizationId) this.userOrganizationId = result.organizationId;
+		if (result === null || result === void 0 ? void 0 : 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 WalletException(/* @__PURE__ */ new Error("OTP ID is required"));
+		if (!targetPublicKey) throw new WalletException(/* @__PURE__ */ new Error("Target public key not found"));
+		if (!this.userOrganizationId) throw new WalletException(/* @__PURE__ */ new Error("Organization ID is required"));
+		const result = await TurnkeyOtpWallet.confirmEmailOTP({
+			otpCode,
+			client: this.client,
+			emailOTPId: this.otpId,
+			organizationId: this.userOrganizationId,
+			targetPublicKey,
+			otpVerifyPath: this.metadata.otpVerifyPath || TURNKEY_OTP_VERIFY_PATH
+		});
+		if (!result || !result.session) throw new WalletException(/* @__PURE__ */ new Error("Failed to confirm OTP"));
+		await indexedDbClient.loginWithSession(result.session);
+		this.userOrganizationId = result.organizationId;
+		return result;
+	}
+	async initOAuth(provider) {
+		var _this$metadata, _this$metadata2;
+		if (provider === TurnkeyProvider.Apple) throw new WalletException(/* @__PURE__ */ new Error("Apple sign in option is currently not supported"));
+		const indexedDbClient = await this.getIndexedDbClient();
+		const nonce = await TurnkeyOauthWallet.generateOAuthNonce(indexedDbClient);
+		if (!((_this$metadata = this.metadata) === null || _this$metadata === void 0 ? void 0 : _this$metadata.googleClientId) || !((_this$metadata2 = this.metadata) === null || _this$metadata2 === void 0 ? void 0 : _this$metadata2.googleRedirectUri)) throw new WalletException(/* @__PURE__ */ new Error("googleClientId and googleRedirectUri are required"));
+		return generateGoogleUrl({
+			nonce,
+			clientId: this.metadata.googleClientId,
+			redirectUri: this.metadata.googleRedirectUri
+		});
+	}
+	async confirmOAuth(provider, oidcToken) {
+		if (provider === TurnkeyProvider.Apple) throw new WalletException(/* @__PURE__ */ new Error("Apple sign in option is currently not supported"));
+		const indexedDbClient = await this.getIndexedDbClient();
+		const oauthResult = await TurnkeyOauthWallet.oauthLogin({
+			oidcToken,
+			indexedDbClient,
+			client: this.client,
+			providerName: provider.toString(),
+			oauthLoginPath: this.metadata.oauthLoginPath || TURNKEY_OAUTH_PATH
+		});
+		if (!oauthResult || !oauthResult.credentialBundle) throw new WalletException(/* @__PURE__ */ new Error("Unexpected OAuth result"));
+		await indexedDbClient.loginWithSession(oauthResult.credentialBundle);
+		this.userOrganizationId = oauthResult.organizationId;
+		return oauthResult.credentialBundle;
+	}
+	async refreshSession() {
+		var _session$session;
+		const session = await this.getSession();
+		const indexedDbClient = await this.getIndexedDbClient();
+		if ((_session$session = session.session) === null || _session$session === void 0 ? void 0 : _session$session.token) {
+			await indexedDbClient.refreshSession({
+				sessionType: SessionType.READ_WRITE,
+				expirationSeconds: this.metadata.expirationSeconds
+			});
+			this.userOrganizationId = session.organizationId;
+			return session.session.token;
+		}
+		throw new TurnkeyWalletSessionException(/* @__PURE__ */ 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
+		};
+	}
+};
+async function createTurnkeyClient(metadata) {
+	const turnkey = new Turnkey(metadata);
+	const indexedDbClient = await turnkey.indexedDbClient();
+	await indexedDbClient.init();
+	if (!turnkey) throw new GeneralException(/* @__PURE__ */ new Error("Turnkey is not initialized"));
+	return {
+		turnkey,
+		indexedDbClient
+	};
+}
+
+//#endregion
+//#region src/strategy/Eip1193Provider.ts
+const getEip1193ProviderForTurnkey = async (account, chainId) => {
+	return 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
+	});
+};
+var CustomEip1193Provider = class {
+	constructor(args) {
+		var _args$chainId;
+		_defineProperty(this, "chainId", void 0);
+		_defineProperty(this, "signTypedData", void 0);
+		_defineProperty(this, "signMessage", void 0);
+		_defineProperty(this, "signTransaction", void 0);
+		_defineProperty(this, "account", void 0);
+		_defineProperty(this, "address", void 0);
+		this.chainId = (_args$chainId = args.chainId) !== null && _args$chainId !== void 0 ? _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 processedTransaction = { ...args.params[0] };
+			for (const field of [
+				"value",
+				"gas",
+				"gasLimit",
+				"gasPrice",
+				"maxFeePerGas",
+				"maxPriorityFeePerGas"
+			]) if (processedTransaction[field] !== void 0) processedTransaction[field] = parseHexValue(processedTransaction[field]);
+			const preparedTransaction = await accountClient.prepareTransactionRequest(processedTransaction);
+			const signedTransaction = await this.signTransaction(preparedTransaction);
+			return await client.sendRawTransaction({ serializedTransaction: signedTransaction });
+		}
+		if (args.method === "eth_getTransactionCount") {
+			if (!args.params) throw new Error("params is required");
+			return `0x${(await getViemPublicClient(this.chainId).getTransactionCount({
+				address: this.address,
+				blockTag: "pending"
+			})).toString(16)}`;
+		}
+		return this.getClient().request({
+			method: args.method,
+			params: args.params
+		});
+	}
+};
+
+//#endregion
+//#region src/strategy/strategy.ts
+var TurnkeyWalletStrategy = class extends BaseConcreteStrategy {
+	constructor(args) {
+		var _this$metadata;
+		super(args);
+		_defineProperty(this, "turnkeyWallet", void 0);
+		_defineProperty(this, "evmOptions", void 0);
+		_defineProperty(this, "client", void 0);
+		const endpoint = args.apiServerEndpoint || ((_this$metadata = this.metadata) === null || _this$metadata === void 0 || (_this$metadata = _this$metadata.turnkey) === null || _this$metadata === void 0 ? void 0 : _this$metadata.apiServerEndpoint);
+		if (!endpoint) throw new WalletException(/* @__PURE__ */ new Error("apiServerEndpoint is required"));
+		this.client = new HttpRestClient(endpoint);
+		this.evmOptions = args.evmOptions;
+	}
+	async getWalletDeviceType() {
+		return Promise.resolve(WalletDeviceType.Browser);
+	}
+	setMetadata(metadata) {
+		if (metadata === null || metadata === void 0 ? void 0 : metadata.turnkey) {
+			var _this$metadata2, _this$turnkeyWallet, _this$metadata3;
+			this.metadata = {
+				...this.metadata,
+				turnkey: {
+					...(_this$metadata2 = this.metadata) === null || _this$metadata2 === void 0 ? void 0 : _this$metadata2.turnkey,
+					...metadata.turnkey
+				}
+			};
+			(_this$turnkeyWallet = this.turnkeyWallet) === null || _this$turnkeyWallet === void 0 || _this$turnkeyWallet.setMetadata((_this$metadata3 = this.metadata) === null || _this$metadata3 === void 0 ? void 0 : _this$metadata3.turnkey);
+		}
+	}
+	async enable() {
+		const turnkeyWallet = await this.getTurnkeyWallet();
+		try {
+			const session = await turnkeyWallet.getSession();
+			if (session.session) {
+				var _this$metadata4;
+				if ((_this$metadata4 = this.metadata) === null || _this$metadata4 === void 0 ? void 0 : _this$metadata4.turnkey) this.metadata.turnkey.session = session.session;
+				return true;
+			}
+			return !!await turnkeyWallet.getIndexedDbClient();
+		} catch (_unused) {
+			return false;
+		}
+	}
+	async disconnect() {
+		const turnkeyWallet = await this.getTurnkeyWallet();
+		const turnkey = await turnkeyWallet.getTurnkey();
+		const indexedDbClient = await turnkeyWallet.getIndexedDbClient();
+		if (!await turnkey.getSession()) return;
+		await Promise.allSettled([turnkey.logout(), indexedDbClient.clear()]);
+	}
+	async getAddresses() {
+		const turnkeyWallet = await this.getTurnkeyWallet();
+		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(_address) {
+		return await (await this.getTurnkeyWallet()).refreshSession();
+	}
+	async getWalletClient() {
+		return await this.getTurnkeyWallet();
+	}
+	async sendEvmTransaction(transaction, args) {
+		try {
+			var _options$rpcUrls;
+			const options = this.evmOptions;
+			const turnkeyWallet = await this.getTurnkeyWallet();
+			const chainId = args.evmChainId || options.evmChainId;
+			const url = options.rpcUrl || ((_options$rpcUrls = options.rpcUrls) === null || _options$rpcUrls === void 0 ? void 0 : _options$rpcUrls[args.evmChainId]);
+			if (!url) throw new WalletException(/* @__PURE__ */ new Error("Please pass rpcUrl within the evmOptions"), {
+				code: UnspecifiedErrorCode,
+				context: WalletAction.SendEvmTransaction
+			});
+			const accountClient = getViemWalletClient({
+				chainId,
+				account: await turnkeyWallet.getOrCreateAndGetAccount(getAddress(args.address)),
+				rpcUrl: url
+			});
+			const parseHexValue = (value) => {
+				if (typeof value === "string") {
+					const hexValue = value.startsWith("0x") ? value : `0x${value}`;
+					return BigInt(hexValue);
+				}
+				return BigInt(value);
+			};
+			const processedTransaction = { ...transaction };
+			for (const field of [
+				"value",
+				"gas",
+				"gasLimit",
+				"gasPrice",
+				"maxFeePerGas",
+				"maxPriorityFeePerGas"
+			]) if (processedTransaction[field] !== void 0) processedTransaction[field] = parseHexValue(processedTransaction[field]);
+			const { account: _, ...transactionToSign } = await accountClient.prepareTransactionRequest(processedTransaction);
+			const signedTransaction = await accountClient.signTransaction(transactionToSign);
+			return await accountClient.sendRawTransaction({ serializedTransaction: signedTransaction });
+		} catch (e) {
+			throw new WalletException(e, {
+				code: UnspecifiedErrorCode,
+				context: WalletAction.SendEvmTransaction
+			});
+		}
+	}
+	async sendTransaction(transaction, options) {
+		const { endpoints, txTimeout } = options;
+		if (!endpoints) throw new WalletException(/* @__PURE__ */ new Error("You have to pass endpoints.grpc within the options for using Turnkey wallet"));
+		const response = await new TxGrpcApi(endpoints.grpc).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 checksumAddress = getAddress(address);
+		const account = await turnkeyWallet.getOrCreateAndGetAccount(checksumAddress);
+		if (!account) throw new WalletException(/* @__PURE__ */ new Error("Turnkey account not found"));
+		let parsedData;
+		try {
+			parsedData = JSON.parse(eip712json);
+		} catch (_unused2) {
+			throw new WalletException(/* @__PURE__ */ new Error("Failed to parse EIP-712 data: Invalid JSON format"), {
+				code: UnspecifiedErrorCode,
+				type: ErrorType.WalletError,
+				contextModule: WalletAction.SignTransaction
+			});
+		}
+		return await account.signTypedData(parsedData);
+	}
+	async signCosmosTransaction(_transaction) {
+		throw new WalletException(/* @__PURE__ */ new Error("This wallet does not support signing Cosmos transactions"), {
+			code: UnspecifiedErrorCode,
+			type: ErrorType.WalletError,
+			contextModule: WalletAction.SignTransaction
+		});
+	}
+	async signAminoCosmosTransaction(_transaction) {
+		throw new WalletException(/* @__PURE__ */ new Error("This wallet does not support signAminoCosmosTransaction"), {
+			code: UnspecifiedErrorCode,
+			type: ErrorType.WalletError,
+			contextModule: WalletAction.SignTransaction
+		});
+	}
+	async signArbitrary(_signer, _data) {
+		throw new WalletException(/* @__PURE__ */ new Error("This wallet does not support signArbitrary"), {
+			code: UnspecifiedErrorCode,
+			type: ErrorType.WalletError,
+			contextModule: WalletAction.SignTransaction
+		});
+	}
+	async getEthereumChainId() {
+		throw new CosmosWalletException(/* @__PURE__ */ new Error("getEthereumChainId is not supported on Turnkey wallet"), {
+			code: UnspecifiedErrorCode,
+			context: WalletAction.GetChainId
+		});
+	}
+	async getEvmTransactionReceipt(txHash, evmChainId) {
+		var _options$rpcUrls2;
+		const options = this.evmOptions;
+		const chainId = evmChainId || options.evmChainId;
+		const url = options.rpcUrl || ((_options$rpcUrls2 = options.rpcUrls) === null || _options$rpcUrls2 === void 0 ? void 0 : _options$rpcUrls2[chainId]);
+		if (!url) throw new WalletException(/* @__PURE__ */ new Error("Please pass rpcUrl within the evmOptions"), {
+			code: UnspecifiedErrorCode,
+			context: WalletAction.GetEvmTransactionReceipt
+		});
+		const publicClient = getViemPublicClient(chainId, url);
+		try {
+			return await publicClient.waitForTransactionReceipt({
+				hash: txHash,
+				timeout: 3e4,
+				pollingInterval: 3e3
+			});
+		} catch (_unused3) {
+			throw new Error(`Failed to retrieve transaction receipt for txHash: ${txHash}`);
+		}
+	}
+	async getPubKey() {
+		throw new WalletException(/* @__PURE__ */ new Error("You can only fetch PubKey from Cosmos native wallets"));
+	}
+	async getIndexedDbClient() {
+		return await (await this.getTurnkeyWallet()).getIndexedDbClient();
+	}
+	async getTurnkeyWallet() {
+		const { metadata } = this;
+		if (!this.turnkeyWallet) {
+			if (!(metadata === null || metadata === void 0 ? void 0 : metadata.turnkey)) throw new WalletException(/* @__PURE__ */ new Error("Turnkey metadata is required"));
+			if (!metadata.turnkey.apiBaseUrl) throw new WalletException(/* @__PURE__ */ new Error("Turnkey apiBaseUrl is required"));
+			if (!metadata.turnkey.apiServerEndpoint) throw new WalletException(/* @__PURE__ */ new Error("Turnkey apiServerEndpoint is required"));
+			this.turnkeyWallet = new TurnkeyWallet(metadata.turnkey);
+		}
+		return this.turnkeyWallet;
+	}
+	async getEip1193Provider() {
+		const turnkeyWallet = await this.getTurnkeyWallet();
+		const checksumAddress = getAddress(getEthereumAddress((await turnkeyWallet.getAccounts())[0]));
+		return await getEip1193ProviderForTurnkey(await turnkeyWallet.getOrCreateAndGetAccount(checksumAddress), String(this.evmOptions.evmChainId));
+	}
+};
+
+//#endregion
+export { TurnkeyWallet, TurnkeyWalletStrategy };

package/dist/esm/package.json

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