@injectivelabs/wallet-trezor 1.16.38 → 1.16.39-alpha.0

package/dist/cjs/index.cjs

@@ -0,0 +1,680 @@
+let viem = require("viem");
+let __injectivelabs_sdk_ts_core_tx = require("@injectivelabs/sdk-ts/core/tx");
+let __injectivelabs_wallet_base = require("@injectivelabs/wallet-base");
+let __injectivelabs_sdk_ts_utils = require("@injectivelabs/sdk-ts/utils");
+let __injectivelabs_exceptions = require("@injectivelabs/exceptions");
+
+//#region src/types.ts
+const TrezorDerivationPathType = {
+	Bip32: "bip32",
+	Bip44: "bip44",
+	Legacy: "legacy"
+};
+
+//#endregion
+//#region src/strategy/lib.ts
+async function loadTrezorConnect() {
+	var _default;
+	const module$1 = await import("@trezor/connect-web");
+	return (module$1 === null || module$1 === void 0 || (_default = module$1.default) === null || _default === void 0 ? void 0 : _default.default) || module$1.default;
+}
+
+//#endregion
+//#region src/utils.ts
+/**
+* Calculates the domain_separator_hash and message_hash from an EIP-712 Typed Data object.
+*
+* The Trezor Model 1 does not currently support constructing the hash on the device,
+* so this function pre-computes them.
+*
+* @template {TypedMessage} T
+* @param {T} data - The EIP-712 Typed Data object.
+* @param {boolean} metamask_v4_compat - Set to `true` for compatibility with Metamask's signTypedData_v4 function.
+* @returns {{domain_separator_hash: string, message_hash?: string} & T} The hashes.
+*/
+const transformTypedData = (data, metamask_v4_compat = true) => {
+	if (!metamask_v4_compat) throw new __injectivelabs_exceptions.TrezorException(/* @__PURE__ */ new Error("Trezor: Only version 4 of typed data signing is supported"));
+	const version = __injectivelabs_sdk_ts_utils.SignTypedDataVersionV4;
+	const { types, primaryType, domain, message } = (0, __injectivelabs_sdk_ts_utils.TypedDataUtilsSanitizeData)(data);
+	const domainSeparatorHash = (0, __injectivelabs_sdk_ts_utils.TypedDataUtilsHashStruct)("EIP712Domain", (0, __injectivelabs_sdk_ts_utils.sanitizeTypedData)(domain), types, version).toString("hex");
+	let messageHash = null;
+	if (primaryType !== "EIP712Domain") messageHash = (0, __injectivelabs_sdk_ts_utils.TypedDataUtilsHashStruct)(primaryType, (0, __injectivelabs_sdk_ts_utils.sanitizeTypedData)(message), {
+		...types,
+		domain: (0, __injectivelabs_sdk_ts_utils.sanitizeTypedData)(domain)
+	}, version).toString("hex");
+	return {
+		domain_separator_hash: domainSeparatorHash,
+		message_hash: messageHash,
+		...data
+	};
+};
+
+//#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/hw/AccountManager.ts
+const addressOfHDKey = (hdKey) => {
+	const shouldSanitizePublicKey = true;
+	const derivedPublicKey = hdKey.publicKey;
+	return (0, __injectivelabs_sdk_ts_utils.addHexPrefix)((0, __injectivelabs_sdk_ts_utils.uint8ArrayToHex)((0, __injectivelabs_sdk_ts_utils.publicKeyToAddress)(derivedPublicKey, shouldSanitizePublicKey)));
+};
+var AccountManager = class {
+	constructor() {
+		_defineProperty(this, "wallets", []);
+		_defineProperty(this, "getTrezorDerivationPathBasedOnType", ({ fullBaseDerivationPath, derivationPathType, index }) => {
+			if (derivationPathType === TrezorDerivationPathType.Bip44) return `${fullBaseDerivationPath}/${index}'/0/0`;
+			if (derivationPathType === TrezorDerivationPathType.Legacy) return `m/${index}`;
+			return `${fullBaseDerivationPath}/0'/0/${index}`;
+		});
+		this.wallets = [];
+	}
+	async getWallets(baseDerivationPath, derivationPathType) {
+		const { start, end } = this.getOffset();
+		/**
+		* 1. Wallets are not yet fetched at all,
+		* 2. Wallets are not yet fetched for that offset
+		*/
+		if (!this.hasWallets() || !this.hasWalletsInOffset(start)) await this.getWalletsBasedOnIndex({
+			start,
+			end,
+			baseDerivationPath,
+			derivationPathType
+		});
+		return this.wallets.slice(start, end);
+	}
+	async getWalletsBasedOnIndex({ start, end, baseDerivationPath, derivationPathType }) {
+		const TrezorConnect = await loadTrezorConnect();
+		const pathsToFetch = [];
+		for (let index = start; index < end; index += 1) {
+			const path = this.getTrezorDerivationPathBasedOnType({
+				fullBaseDerivationPath: baseDerivationPath,
+				derivationPathType,
+				index
+			});
+			pathsToFetch.push({
+				path,
+				showOnTrezor: false
+			});
+		}
+		const result = await TrezorConnect.ethereumGetPublicKey({ bundle: pathsToFetch });
+		if (!result.success) throw new __injectivelabs_exceptions.TrezorException(new Error(result.payload && result.payload.error || "Please make sure your Trezor is connected and unlocked"));
+		for (const item of result.payload) {
+			const hdKey = {
+				publicKey: (0, __injectivelabs_sdk_ts_utils.hexToUint8Array)(item.publicKey),
+				chainCode: (0, __injectivelabs_sdk_ts_utils.hexToUint8Array)(item.chainCode)
+			};
+			const address = addressOfHDKey(hdKey);
+			this.wallets.push({
+				hdKey,
+				derivationPath: item.serializedPath,
+				address: address.toLowerCase()
+			});
+		}
+	}
+	hasWallets() {
+		return this.wallets.length > 0;
+	}
+	hasWalletsInOffset(offset) {
+		return this.wallets.length > offset;
+	}
+	getOffset() {
+		const totalWallets = this.wallets.length;
+		return {
+			start: totalWallets,
+			end: totalWallets + __injectivelabs_wallet_base.DEFAULT_NUM_ADDRESSES_TO_FETCH
+		};
+	}
+	hasWalletForAddress(address) {
+		return this.wallets.find((wallet) => wallet.address.toLowerCase() === address.toLowerCase()) !== void 0;
+	}
+	async getWalletForAddress(address) {
+		return this.wallets.find((wallet) => wallet.address.toLowerCase() === address.toLowerCase());
+	}
+	reset() {
+		this.wallets = [];
+	}
+};
+
+//#endregion
+//#region src/strategy/hw/transport/base.ts
+const TREZOR_CONNECT_MANIFEST = {
+	email: "contact@injectivelabs.org",
+	appUrl: "https://injectivelabs.org",
+	appName: "Injective Labs"
+};
+var BaseTrezorTransport = class {
+	constructor() {
+		_defineProperty(this, "accountManager", null);
+	}
+	async connect() {
+		const TrezorConnect = await loadTrezorConnect();
+		if (!(await TrezorConnect.getSettings()).success) await TrezorConnect.init({
+			lazyLoad: true,
+			coreMode: "popup",
+			manifest: TREZOR_CONNECT_MANIFEST
+		});
+		return Promise.resolve();
+	}
+	async getAccountManager() {
+		if (!this.accountManager) this.accountManager = new AccountManager();
+		return this.accountManager;
+	}
+};
+
+//#endregion
+//#region src/strategy/Eip1193Provider.ts
+var TrezorEip1193Provider = class {
+	constructor(trezor, params) {
+		_defineProperty(this, "trezor", void 0);
+		_defineProperty(this, "derivationPath", void 0);
+		_defineProperty(this, "address", void 0);
+		_defineProperty(this, "chainId", void 0);
+		this.trezor = trezor;
+		this.derivationPath = params.derivationPath || "m/44'/60'/0'/0/0";
+		this.chainId = parseInt(params.chainId || "1");
+	}
+	async getClient() {
+		return (0, __injectivelabs_wallet_base.getViemWalletClient)({
+			chainId: this.chainId,
+			account: await this.getAddress()
+		});
+	}
+	async setChainId(chainId) {
+		this.chainId = parseInt(chainId.replace("0x", ""), 16);
+	}
+	async getAddress() {
+		if (!this.address) {
+			const TrezorConnect = await loadTrezorConnect();
+			await this.trezor.connect();
+			const response = await TrezorConnect.ethereumGetAddress({
+				path: this.derivationPath,
+				showOnTrezor: false
+			});
+			if (!response.success) throw new Error(response.payload && response.payload.error || "Failed to get address from Trezor");
+			this.address = response.payload.address;
+		}
+		return this.address;
+	}
+	async signTypedData(data) {
+		const TrezorConnect = await loadTrezorConnect();
+		await this.trezor.connect();
+		const object = JSON.parse(data);
+		const { types: { EIP712Domain = [], ...otherTypes } = {}, message = {}, domain = {}, primaryType, domain_separator_hash, message_hash } = transformTypedData({
+			...object,
+			domain: {
+				...object.domain,
+				chainId: object.domain.chainId,
+				salt: "0"
+			}
+		});
+		const response = await TrezorConnect.ethereumSignTypedData({
+			path: this.derivationPath,
+			data: {
+				types: {
+					EIP712Domain,
+					...otherTypes
+				},
+				message,
+				domain,
+				primaryType
+			},
+			message_hash,
+			domain_separator_hash,
+			metamask_v4_compat: true
+		});
+		if ("code" in response.payload && response.payload.code === "Failure_ActionCancelled") throw new Error("Request rejected");
+		if (!response.success) throw new Error(response.payload && response.payload.error || "Unknown error");
+		return response.payload.signature;
+	}
+	async signTransaction(txData) {
+		const TrezorConnect = await loadTrezorConnect();
+		await this.trezor.connect();
+		const parseHexValue = (value) => {
+			if (typeof value === "string") {
+				const hexValue = value.startsWith("0x") ? value : `0x${value}`;
+				return BigInt(hexValue);
+			}
+			return BigInt(value);
+		};
+		const chainId = txData.chainId || this.chainId;
+		const valueBigInt = parseHexValue(txData.value || "0x0");
+		const gasBigInt = parseHexValue(txData.gas || txData.gasLimit);
+		const maxFeePerGasBigInt = parseHexValue(txData.maxFeePerGas);
+		const maxPriorityFeePerGasBigInt = parseHexValue(txData.maxPriorityFeePerGas);
+		const trezorTxData = {
+			to: txData.to,
+			value: (0, viem.toHex)(valueBigInt),
+			gasLimit: (0, viem.toHex)(gasBigInt),
+			nonce: (0, viem.toHex)(txData.nonce),
+			data: txData.data || "0x",
+			chainId,
+			maxFeePerGas: (0, viem.toHex)(maxFeePerGasBigInt),
+			maxPriorityFeePerGas: (0, viem.toHex)(maxPriorityFeePerGasBigInt)
+		};
+		const response = await TrezorConnect.ethereumSignTransaction({
+			path: this.derivationPath,
+			transaction: trezorTxData
+		});
+		if (!response.success) throw new Error(response.payload && response.payload.error || "Something happened while signing with Trezor");
+		return (0, viem.serializeTransaction)({
+			type: "eip1559",
+			chainId,
+			nonce: txData.nonce,
+			to: txData.to,
+			value: valueBigInt,
+			data: txData.data || "0x",
+			gas: gasBigInt,
+			maxFeePerGas: maxFeePerGasBigInt,
+			maxPriorityFeePerGas: maxPriorityFeePerGasBigInt,
+			v: BigInt(response.payload.v),
+			r: response.payload.r,
+			s: response.payload.s
+		});
+	}
+	async signMessage(message) {
+		const TrezorConnect = await loadTrezorConnect();
+		await this.trezor.connect();
+		const response = await TrezorConnect.ethereumSignMessage({
+			path: this.derivationPath,
+			message
+		});
+		if (!response.success) throw new Error(response.payload && response.payload.error || "Unknown error");
+		const signature = response.payload.signature;
+		return signature.startsWith("0x") ? signature : `0x${signature}`;
+	}
+	getChain() {
+		return (0, __injectivelabs_wallet_base.getEvmChainConfig)(this.chainId);
+	}
+	async request(args) {
+		if (args.method === "eth_requestAccounts") return [await this.getAddress()];
+		if (args.method === "eth_sign") {
+			if (!args.params[0]) throw new Error("Missing parameter for eth_sign");
+			return this.signMessage(args.params[0]);
+		}
+		if (args.method === "eth_signTransaction") {
+			if (!args.params[0]) throw new Error("Missing parameter for eth_signTransaction");
+			return this.signTransaction(args.params[0]);
+		}
+		if (args.method === "eth_signTypedData") {
+			if (!args.params[0]) throw new Error("Missing parameter for eth_signTypedData");
+			return this.signTypedData(args.params[0]);
+		}
+		if (args.method === "eth_chainId") return `0x${this.chainId.toString(16)}`;
+		if (args.method === "wallet_switchEthereumChain") {
+			var _args$params$;
+			return this.setChainId(((_args$params$ = args.params[0]) === null || _args$params$ === void 0 ? void 0 : _args$params$.chainId) || "0x1");
+		}
+		if (args.method === "eth_estimateGas") {
+			const client = (0, __injectivelabs_wallet_base.getViemPublicClient)(this.chainId);
+			const data = {
+				to: args.params[0].to,
+				value: args.params[0].value,
+				data: args.params[0].data,
+				account: await this.getAddress()
+			};
+			return `0x${(await client.estimateGas(data)).toString(16)}`;
+		}
+		if (args.method === "eth_getTransactionCount") {
+			if (!args.params) throw new Error("params is required");
+			return `0x${(await (0, __injectivelabs_wallet_base.getViemPublicClient)(this.chainId).getTransactionCount({
+				address: await this.getAddress(),
+				blockTag: "pending"
+			})).toString(16)}`;
+		}
+		if (args.method === "eth_sendTransaction") {
+			const address = await this.getAddress();
+			const walletClient = (0, __injectivelabs_wallet_base.getViemWalletClient)({
+				chainId: this.chainId,
+				account: address
+			});
+			const preparedTransaction = await walletClient.prepareTransactionRequest({ ...args.params[0] });
+			const signedTransaction = await this.signTransaction(preparedTransaction);
+			return await walletClient.sendRawTransaction({ serializedTransaction: signedTransaction });
+		}
+		return (await this.getClient()).request({
+			method: args.method,
+			params: args.params
+		});
+	}
+	on(_event, _listener) {
+		throw new Error("Method not implemented.");
+	}
+	once(_event, _listener) {
+		throw new Error("Method not implemented.");
+	}
+	removeListener(_event, _listener) {
+		throw new Error("Method not implemented.");
+	}
+	off(_event, _listener) {
+		throw new Error("Method not implemented.");
+	}
+};
+
+//#endregion
+//#region src/strategy/Base.ts
+var TrezorBase = class extends __injectivelabs_wallet_base.BaseConcreteStrategy {
+	constructor(args) {
+		super(args);
+		_defineProperty(this, "baseDerivationPath", void 0);
+		_defineProperty(this, "trezor", void 0);
+		_defineProperty(this, "evmOptions", void 0);
+		_defineProperty(this, "publicClient", void 0);
+		_defineProperty(this, "derivationPathType", void 0);
+		this.evmOptions = args.evmOptions;
+		this.trezor = new BaseTrezorTransport();
+		this.derivationPathType = args.derivationPathType;
+		this.baseDerivationPath = __injectivelabs_wallet_base.DEFAULT_BASE_DERIVATION_PATH;
+	}
+	async getWalletDeviceType() {
+		return Promise.resolve(__injectivelabs_wallet_base.WalletDeviceType.Hardware);
+	}
+	async enable() {
+		return Promise.resolve(true);
+	}
+	async disconnect() {
+		return Promise.resolve();
+	}
+	async getAddresses() {
+		const { baseDerivationPath, derivationPathType } = this;
+		try {
+			await this.trezor.connect();
+			return (await (await this.trezor.getAccountManager()).getWallets(baseDerivationPath, derivationPathType)).map((k) => k.address);
+		} catch (e) {
+			throw new __injectivelabs_exceptions.TrezorException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.GetAccounts
+			});
+		}
+	}
+	async getAddressesInfo() {
+		const { baseDerivationPath, derivationPathType } = this;
+		try {
+			await this.trezor.connect();
+			return (await (await this.trezor.getAccountManager()).getWallets(baseDerivationPath, derivationPathType)).map((k) => ({
+				address: k.address,
+				derivationPath: k.derivationPath,
+				baseDerivationPath: derivationPathType
+			}));
+		} catch (e) {
+			throw new __injectivelabs_exceptions.TrezorException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.GetAccounts
+			});
+		}
+	}
+	async getSessionOrConfirm(address) {
+		return Promise.resolve(`0x${(0, __injectivelabs_sdk_ts_utils.uint8ArrayToHex)((0, __injectivelabs_sdk_ts_utils.stringToUint8Array)(`Confirmation for ${address} at time: ${Date.now()}`))}`);
+	}
+	async sendEvmTransaction(txData, args) {
+		const signedTransaction = await this.signEvmTransaction(txData, args);
+		try {
+			return await (await this.getPublicClient(args.evmChainId)).sendRawTransaction({ serializedTransaction: signedTransaction });
+		} catch (e) {
+			throw new __injectivelabs_exceptions.TrezorException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.SendEvmTransaction
+			});
+		}
+	}
+	async sendTransaction(transaction, options) {
+		const { endpoints, txTimeout } = options;
+		if (!endpoints) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("You have to pass endpoints.grpc within the options for using Ethereum native wallets"));
+		const response = await new __injectivelabs_sdk_ts_core_tx.TxGrpcApi(endpoints.grpc).broadcast(transaction, { txTimeout });
+		if (response.code !== 0) throw new __injectivelabs_exceptions.TransactionException(new Error(response.rawLog), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			contextCode: response.code,
+			contextModule: response.codespace
+		});
+		return response;
+	}
+	async signEip712TypedData(eip712json, address) {
+		const TrezorConnect = await loadTrezorConnect();
+		const object = JSON.parse(eip712json);
+		const { types: { EIP712Domain = [], ...otherTypes } = {}, message = {}, domain = {}, primaryType, domain_separator_hash, message_hash } = transformTypedData({
+			...object,
+			domain: {
+				...object.domain,
+				chainId: object.domain.chainId,
+				salt: "0"
+			}
+		});
+		try {
+			await this.trezor.connect();
+			const { derivationPath } = await this.getWalletForAddress(address);
+			const response = await TrezorConnect.ethereumSignTypedData({
+				path: derivationPath,
+				data: {
+					types: {
+						EIP712Domain,
+						...otherTypes
+					},
+					message,
+					domain,
+					primaryType
+				},
+				message_hash,
+				domain_separator_hash,
+				metamask_v4_compat: true
+			});
+			if ("code" in response.payload && response.payload.code === "Failure_ActionCancelled") throw new Error("Request rejected");
+			if (!response.success) throw new Error(response.payload && response.payload.error || "Unknown error");
+			return response.payload.signature;
+		} catch (e) {
+			throw new __injectivelabs_exceptions.TrezorException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.SignTransaction
+			});
+		}
+	}
+	async signAminoCosmosTransaction(_transaction) {
+		throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("This wallet does not support signing Cosmos transactions"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			type: __injectivelabs_exceptions.ErrorType.WalletError,
+			contextModule: __injectivelabs_wallet_base.WalletAction.SendTransaction
+		});
+	}
+	async signCosmosTransaction(_transaction) {
+		throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("This wallet does not support signing Cosmos transactions"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			type: __injectivelabs_exceptions.ErrorType.WalletError,
+			contextModule: __injectivelabs_wallet_base.WalletAction.SendTransaction
+		});
+	}
+	async signArbitrary(signer, data) {
+		const TrezorConnect = await loadTrezorConnect();
+		try {
+			await this.trezor.connect();
+			const { derivationPath } = await this.getWalletForAddress(signer);
+			const response = await TrezorConnect.ethereumSignMessage({
+				path: derivationPath,
+				message: (0, __injectivelabs_sdk_ts_utils.toUtf8)(data)
+			});
+			if (!response.success) throw new Error(response.payload && response.payload.error || "Unknown error");
+			return response.payload.signature;
+		} catch (e) {
+			throw new __injectivelabs_exceptions.TrezorException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.SignTransaction
+			});
+		}
+	}
+	async getEthereumChainId() {
+		return (await (await this.getPublicClient()).getChainId()).toString();
+	}
+	async getEvmTransactionReceipt(txHash, evmChainId) {
+		const publicClient = await this.getPublicClient(evmChainId);
+		try {
+			await publicClient.waitForTransactionReceipt({
+				hash: txHash,
+				timeout: 3e4,
+				pollingInterval: 3e3
+			});
+			return txHash;
+		} catch (_unused) {
+			throw new Error(`Failed to retrieve transaction receipt for txHash: ${txHash}`);
+		}
+	}
+	async getPubKey() {
+		throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("You can only fetch PubKey from Cosmos native wallets"));
+	}
+	async signEvmTransaction(txData, args) {
+		const TrezorConnect = await loadTrezorConnect();
+		const chainId = parseInt(args.evmChainId.toString(), 10);
+		const publicClient = await this.getPublicClient(args.evmChainId);
+		const address = args.address.startsWith("0x") ? args.address : `0x${args.address}`;
+		const nonce = await publicClient.getTransactionCount({ address });
+		const parseHexValue = (value) => {
+			if (typeof value === "string") {
+				const hexValue = value.startsWith("0x") ? value : `0x${value}`;
+				return BigInt(hexValue);
+			}
+			return BigInt(value);
+		};
+		const valueBigInt = parseHexValue(txData.value || "0x0");
+		const gasBigInt = parseHexValue(txData.gas);
+		const maxFeePerGasBigInt = parseHexValue(txData.maxFeePerGas);
+		const maxPriorityFeePerGasBigInt = parseHexValue(txData.maxPriorityFeePerGas);
+		const trezorTxData = {
+			to: txData.to,
+			value: (0, viem.toHex)(valueBigInt),
+			gasLimit: (0, viem.toHex)(gasBigInt),
+			nonce: (0, viem.toHex)(nonce),
+			data: txData.data || "0x",
+			chainId,
+			maxFeePerGas: (0, viem.toHex)(maxFeePerGasBigInt),
+			maxPriorityFeePerGas: (0, viem.toHex)(maxPriorityFeePerGasBigInt)
+		};
+		try {
+			await this.trezor.connect();
+			const { derivationPath } = await this.getWalletForAddress(args.address);
+			const response = await TrezorConnect.ethereumSignTransaction({
+				path: derivationPath,
+				transaction: trezorTxData
+			});
+			if (!response.success) throw new __injectivelabs_exceptions.TrezorException(new Error(response.payload && response.payload.error || "Something happened while signing with Trezor"), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.SignEvmTransaction
+			});
+			return (0, viem.serializeTransaction)({
+				type: "eip1559",
+				chainId,
+				nonce,
+				to: txData.to,
+				value: valueBigInt,
+				data: txData.data || "0x",
+				gas: gasBigInt,
+				maxFeePerGas: maxFeePerGasBigInt,
+				maxPriorityFeePerGas: maxPriorityFeePerGasBigInt,
+				v: BigInt(response.payload.v),
+				r: response.payload.r,
+				s: response.payload.s
+			});
+		} catch (e) {
+			if (e instanceof __injectivelabs_exceptions.TrezorException) throw e;
+			throw new __injectivelabs_exceptions.TrezorException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.SignEvmTransaction
+			});
+		}
+	}
+	async getWalletForAddress(address) {
+		const { baseDerivationPath, derivationPathType } = this;
+		const accountManager = await this.trezor.getAccountManager();
+		if (!accountManager.hasWalletForAddress(address)) for (let i = 0; i < __injectivelabs_wallet_base.DEFAULT_ADDRESS_SEARCH_LIMIT / __injectivelabs_wallet_base.DEFAULT_NUM_ADDRESSES_TO_FETCH; i += 1) {
+			await accountManager.getWallets(baseDerivationPath, derivationPathType);
+			if (accountManager.hasWalletForAddress(address)) return await accountManager.getWalletForAddress(address);
+		}
+		return await accountManager.getWalletForAddress(address);
+	}
+	async getEip1193Provider() {
+		var _this$metadata;
+		return new TrezorEip1193Provider(this.trezor, {
+			chainId: this.evmOptions.evmChainId.toString(),
+			derivationPath: (_this$metadata = this.metadata) === null || _this$metadata === void 0 ? void 0 : _this$metadata.derivationPath
+		});
+	}
+	async getPublicClient(evmChainId) {
+		var _options$rpcUrls;
+		if (this.publicClient) return this.publicClient;
+		const options = this.evmOptions;
+		const chainId = evmChainId || options.evmChainId;
+		const url = options.rpcUrl || ((_options$rpcUrls = options.rpcUrls) === null || _options$rpcUrls === void 0 ? void 0 : _options$rpcUrls[chainId]);
+		if (!url) throw new __injectivelabs_exceptions.GeneralException(/* @__PURE__ */ new Error("Please pass rpcUrl within the ethereumOptions"));
+		this.publicClient = (0, __injectivelabs_wallet_base.getViemPublicClient)(chainId, url);
+		return this.publicClient;
+	}
+};
+
+//#endregion
+//#region src/strategy/TrezorBip32.ts
+var TrezorBip32 = class extends TrezorBase {
+	constructor(args) {
+		super({
+			...args,
+			derivationPathType: TrezorDerivationPathType.Bip32
+		});
+	}
+};
+
+//#endregion
+//#region src/strategy/TrezorBip44.ts
+var TrezorBip44 = class extends TrezorBase {
+	constructor(args) {
+		super({
+			...args,
+			derivationPathType: TrezorDerivationPathType.Bip44
+		});
+	}
+};
+
+//#endregion
+exports.TrezorBip32Strategy = TrezorBip32;
+exports.TrezorBip44Strategy = TrezorBip44;
+exports.TrezorDerivationPathType = TrezorDerivationPathType;