@injectivelabs/wallet-trezor 1.16.38-alpha.2 → 1.16.38-alpha.4

package/dist/cjs/index.cjs

@@ -1,6 +1,7 @@
 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 = require("@injectivelabs/sdk-ts");
+let __injectivelabs_sdk_ts_utils = require("@injectivelabs/sdk-ts/utils");
 let __injectivelabs_exceptions = require("@injectivelabs/exceptions");
 
 //#region src/types.ts
@@ -33,13 +34,13 @@ async function loadTrezorConnect() {
 */
 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.SignTypedDataVersionV4;
-	const { types, primaryType, domain, message } = (0, __injectivelabs_sdk_ts.TypedDataUtilsSanitizeData)(data);
-	const domainSeparatorHash = (0, __injectivelabs_sdk_ts.TypedDataUtilsHashStruct)("EIP712Domain", (0, __injectivelabs_sdk_ts.sanitizeTypedData)(domain), types, version).toString("hex");
+	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.TypedDataUtilsHashStruct)(primaryType, (0, __injectivelabs_sdk_ts.sanitizeTypedData)(message), {
+	if (primaryType !== "EIP712Domain") messageHash = (0, __injectivelabs_sdk_ts_utils.TypedDataUtilsHashStruct)(primaryType, (0, __injectivelabs_sdk_ts_utils.sanitizeTypedData)(message), {
 		...types,
-		domain: (0, __injectivelabs_sdk_ts.sanitizeTypedData)(domain)
+		domain: (0, __injectivelabs_sdk_ts_utils.sanitizeTypedData)(domain)
 	}, version).toString("hex");
 	return {
 		domain_separator_hash: domainSeparatorHash,
@@ -95,7 +96,7 @@ function _defineProperty(e, r, t) {
 const addressOfHDKey = (hdKey) => {
 	const shouldSanitizePublicKey = true;
 	const derivedPublicKey = hdKey.publicKey;
-	return (0, __injectivelabs_sdk_ts.addHexPrefix)((0, __injectivelabs_sdk_ts.uint8ArrayToHex)((0, __injectivelabs_sdk_ts.publicKeyToAddress)(derivedPublicKey, shouldSanitizePublicKey)));
+	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() {
@@ -139,8 +140,8 @@ var AccountManager = class {
 		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.hexToUint8Array)(item.publicKey),
-				chainCode: (0, __injectivelabs_sdk_ts.hexToUint8Array)(item.chainCode)
+				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({
@@ -200,6 +201,195 @@ var BaseTrezorTransport = class {
 	}
 };
 
+//#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 {
@@ -237,8 +427,25 @@ var TrezorBase = class extends __injectivelabs_wallet_base.BaseConcreteStrategy
 			});
 		}
 	}
+	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.uint8ArrayToHex)((0, __injectivelabs_sdk_ts.stringToUint8Array)(`Confirmation for ${address} at time: ${Date.now()}`))}`);
+		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);
@@ -255,7 +462,7 @@ var TrezorBase = class extends __injectivelabs_wallet_base.BaseConcreteStrategy
 	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.TxGrpcApi(endpoints.grpc).broadcast(transaction, { txTimeout });
+		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,
@@ -324,7 +531,7 @@ var TrezorBase = class extends __injectivelabs_wallet_base.BaseConcreteStrategy
 			const { derivationPath } = await this.getWalletForAddress(signer);
 			const response = await TrezorConnect.ethereumSignMessage({
 				path: derivationPath,
-				message: (0, __injectivelabs_sdk_ts.toUtf8)(data)
+				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;
@@ -426,6 +633,13 @@ var TrezorBase = class extends __injectivelabs_wallet_base.BaseConcreteStrategy
 		}
 		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;

package/dist/cjs/index.d.cts

@@ -1,6 +1,7 @@
-import { BaseConcreteStrategy, ConcreteEvmWalletStrategyArgs, ConcreteWalletStrategy, SendTransactionOptions, StdSignDoc, WalletDeviceType } from "@injectivelabs/wallet-base";
+import { BaseConcreteStrategy, ConcreteEvmWalletStrategyArgs, ConcreteWalletStrategy, Eip1193Provider, SendTransactionOptions, StdSignDoc, WalletDeviceType } from "@injectivelabs/wallet-base";
 import { AccountAddress, EvmChainId } from "@injectivelabs/ts-types";
-import { AminoSignResponse, DirectSignResponse, TxRaw, TxResponse } from "@injectivelabs/sdk-ts";
+import { TxResponse } from "@injectivelabs/sdk-ts/core/tx";
+import { AminoSignResponse, DirectSignResponse, TxRaw } from "@injectivelabs/sdk-ts/types";
 
 //#region src/types.d.ts
 interface HDNodeLike {
@@ -33,6 +34,11 @@ declare class TrezorBase extends BaseConcreteStrategy implements ConcreteWalletS
   enable(): Promise<boolean>;
   disconnect(): Promise<void>;
   getAddresses(): Promise<string[]>;
+  getAddressesInfo(): Promise<{
+    address: string;
+    derivationPath: string;
+    baseDerivationPath: string;
+  }[]>;
   getSessionOrConfirm(address: AccountAddress): Promise<string>;
   sendEvmTransaction(txData: any, args: {
     address: string;
@@ -56,6 +62,7 @@ declare class TrezorBase extends BaseConcreteStrategy implements ConcreteWalletS
   getPubKey(): Promise<string>;
   private signEvmTransaction;
   private getWalletForAddress;
+  getEip1193Provider(): Promise<Eip1193Provider>;
   private getPublicClient;
 }
 //#endregion

package/dist/esm/index.d.ts

@@ -1,6 +1,7 @@
-import { BaseConcreteStrategy, ConcreteEvmWalletStrategyArgs, ConcreteWalletStrategy, SendTransactionOptions, StdSignDoc, WalletDeviceType } from "@injectivelabs/wallet-base";
-import { AminoSignResponse, DirectSignResponse, TxRaw, TxResponse } from "@injectivelabs/sdk-ts";
+import { TxResponse } from "@injectivelabs/sdk-ts/core/tx";
+import { BaseConcreteStrategy, ConcreteEvmWalletStrategyArgs, ConcreteWalletStrategy, Eip1193Provider, SendTransactionOptions, StdSignDoc, WalletDeviceType } from "@injectivelabs/wallet-base";
 import { AccountAddress, EvmChainId } from "@injectivelabs/ts-types";
+import { AminoSignResponse, DirectSignResponse, TxRaw } from "@injectivelabs/sdk-ts/types";
 
 //#region src/types.d.ts
 interface HDNodeLike {
@@ -33,6 +34,11 @@ declare class TrezorBase extends BaseConcreteStrategy implements ConcreteWalletS
   enable(): Promise<boolean>;
   disconnect(): Promise<void>;
   getAddresses(): Promise<string[]>;
+  getAddressesInfo(): Promise<{
+    address: string;
+    derivationPath: string;
+    baseDerivationPath: string;
+  }[]>;
   getSessionOrConfirm(address: AccountAddress): Promise<string>;
   sendEvmTransaction(txData: any, args: {
     address: string;
@@ -56,6 +62,7 @@ declare class TrezorBase extends BaseConcreteStrategy implements ConcreteWalletS
   getPubKey(): Promise<string>;
   private signEvmTransaction;
   private getWalletForAddress;
+  getEip1193Provider(): Promise<Eip1193Provider>;
   private getPublicClient;
 }
 //#endregion

package/dist/esm/index.js

@@ -1,6 +1,7 @@
 import { serializeTransaction, toHex } from "viem";
-import { BaseConcreteStrategy, DEFAULT_ADDRESS_SEARCH_LIMIT, DEFAULT_BASE_DERIVATION_PATH, DEFAULT_NUM_ADDRESSES_TO_FETCH, WalletAction, WalletDeviceType, getViemPublicClient } from "@injectivelabs/wallet-base";
-import { SignTypedDataVersionV4, TxGrpcApi, TypedDataUtilsHashStruct, TypedDataUtilsSanitizeData, addHexPrefix, hexToUint8Array, publicKeyToAddress, sanitizeTypedData, stringToUint8Array, toUtf8, uint8ArrayToHex } from "@injectivelabs/sdk-ts";
+import { TxGrpcApi } from "@injectivelabs/sdk-ts/core/tx";
+import { BaseConcreteStrategy, DEFAULT_ADDRESS_SEARCH_LIMIT, DEFAULT_BASE_DERIVATION_PATH, DEFAULT_NUM_ADDRESSES_TO_FETCH, WalletAction, WalletDeviceType, getEvmChainConfig, getViemPublicClient, getViemWalletClient } from "@injectivelabs/wallet-base";
+import { SignTypedDataVersionV4, TypedDataUtilsHashStruct, TypedDataUtilsSanitizeData, addHexPrefix, hexToUint8Array, publicKeyToAddress, sanitizeTypedData, stringToUint8Array, toUtf8, uint8ArrayToHex } from "@injectivelabs/sdk-ts/utils";
 import { ErrorType, GeneralException, TransactionException, TrezorException, UnspecifiedErrorCode, WalletException } from "@injectivelabs/exceptions";
 
 //#region src/types.ts
@@ -200,6 +201,195 @@ var BaseTrezorTransport = class {
 	}
 };
 
+//#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 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: toHex(valueBigInt),
+			gasLimit: toHex(gasBigInt),
+			nonce: toHex(txData.nonce),
+			data: txData.data || "0x",
+			chainId,
+			maxFeePerGas: toHex(maxFeePerGasBigInt),
+			maxPriorityFeePerGas: 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 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 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 = 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 getViemPublicClient(this.chainId).getTransactionCount({
+				address: await this.getAddress(),
+				blockTag: "pending"
+			})).toString(16)}`;
+		}
+		if (args.method === "eth_sendTransaction") {
+			const address = await this.getAddress();
+			const walletClient = 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 BaseConcreteStrategy {
@@ -237,6 +427,23 @@ var TrezorBase = class extends BaseConcreteStrategy {
 			});
 		}
 	}
+	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 TrezorException(new Error(e.message), {
+				code: UnspecifiedErrorCode,
+				type: ErrorType.WalletError,
+				contextModule: WalletAction.GetAccounts
+			});
+		}
+	}
 	async getSessionOrConfirm(address) {
 		return Promise.resolve(`0x${uint8ArrayToHex(stringToUint8Array(`Confirmation for ${address} at time: ${Date.now()}`))}`);
 	}
@@ -426,6 +633,13 @@ var TrezorBase = class extends BaseConcreteStrategy {
 		}
 		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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@injectivelabs/wallet-trezor",
-  "version": "1.16.38-alpha.2",
+  "version": "1.16.38-alpha.4",
   "description": "Trezor wallet strategy for use with @injectivelabs/wallet-core.",
   "license": "Apache-2.0",
   "author": {
@@ -40,11 +40,11 @@
   "dependencies": {
     "@trezor/connect": "^9.6.4",
     "@trezor/connect-web": "^9.6.4",
-    "viem": "^2.40.3",
-    "@injectivelabs/exceptions": "1.16.38-alpha.1",
-    "@injectivelabs/ts-types": "1.16.38-alpha.1",
-    "@injectivelabs/sdk-ts": "1.16.38-alpha.2",
-    "@injectivelabs/wallet-base": "1.16.38-alpha.2"
+    "viem": "^2.41.2",
+    "@injectivelabs/exceptions": "1.16.38-alpha.3",
+    "@injectivelabs/ts-types": "1.16.38-alpha.2",
+    "@injectivelabs/wallet-base": "1.16.38-alpha.4",
+    "@injectivelabs/sdk-ts": "1.16.38-alpha.4"
   },
   "publishConfig": {
     "access": "public"