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

package/dist/cjs/index.cjs

@@ -0,0 +1,466 @@
+let viem = require("viem");
+let __injectivelabs_wallet_base = require("@injectivelabs/wallet-base");
+let __injectivelabs_sdk_ts = require("@injectivelabs/sdk-ts");
+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.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");
+	let messageHash = null;
+	if (primaryType !== "EIP712Domain") messageHash = (0, __injectivelabs_sdk_ts.TypedDataUtilsHashStruct)(primaryType, (0, __injectivelabs_sdk_ts.sanitizeTypedData)(message), {
+		...types,
+		domain: (0, __injectivelabs_sdk_ts.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.addHexPrefix)((0, __injectivelabs_sdk_ts.uint8ArrayToHex)((0, __injectivelabs_sdk_ts.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.hexToUint8Array)(item.publicKey),
+				chainCode: (0, __injectivelabs_sdk_ts.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/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 getSessionOrConfirm(address) {
+		return Promise.resolve(`0x${(0, __injectivelabs_sdk_ts.uint8ArrayToHex)((0, __injectivelabs_sdk_ts.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.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.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 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;

package/dist/cjs/index.d.cts

@@ -0,0 +1,72 @@
+import { BaseConcreteStrategy, ConcreteEvmWalletStrategyArgs, ConcreteWalletStrategy, SendTransactionOptions, StdSignDoc, WalletDeviceType } from "@injectivelabs/wallet-base";
+import { AccountAddress, EvmChainId } from "@injectivelabs/ts-types";
+import { AminoSignResponse, DirectSignResponse, TxRaw, TxResponse } from "@injectivelabs/sdk-ts";
+
+//#region src/types.d.ts
+interface HDNodeLike {
+  publicKey: Uint8Array;
+  chainCode: Uint8Array;
+}
+declare const TrezorDerivationPathType: {
+  readonly Bip32: "bip32";
+  readonly Bip44: "bip44";
+  readonly Legacy: "legacy";
+};
+type TrezorDerivationPathType = (typeof TrezorDerivationPathType)[keyof typeof TrezorDerivationPathType];
+interface TrezorWalletInfo {
+  address: string;
+  hdKey: HDNodeLike;
+  derivationPath: string;
+}
+//#endregion
+//#region src/strategy/Base.d.ts
+declare class TrezorBase extends BaseConcreteStrategy implements ConcreteWalletStrategy {
+  private baseDerivationPath;
+  private trezor;
+  private evmOptions;
+  private publicClient;
+  private derivationPathType;
+  constructor(args: ConcreteEvmWalletStrategyArgs & {
+    derivationPathType: TrezorDerivationPathType;
+  });
+  getWalletDeviceType(): Promise<WalletDeviceType>;
+  enable(): Promise<boolean>;
+  disconnect(): Promise<void>;
+  getAddresses(): Promise<string[]>;
+  getSessionOrConfirm(address: AccountAddress): Promise<string>;
+  sendEvmTransaction(txData: any, args: {
+    address: string;
+    evmChainId: EvmChainId;
+  }): Promise<string>;
+  sendTransaction(transaction: TxRaw, options: SendTransactionOptions): Promise<TxResponse>;
+  signEip712TypedData(eip712json: string, address: AccountAddress): Promise<string>;
+  signAminoCosmosTransaction(_transaction: {
+    address: string;
+    signDoc: StdSignDoc;
+  }): Promise<AminoSignResponse>;
+  signCosmosTransaction(_transaction: {
+    txRaw: TxRaw;
+    accountNumber: number;
+    chainId: string;
+    address: string;
+  }): Promise<DirectSignResponse>;
+  signArbitrary(signer: AccountAddress, data: string | Uint8Array): Promise<string>;
+  getEthereumChainId(): Promise<string>;
+  getEvmTransactionReceipt(txHash: string, evmChainId?: EvmChainId): Promise<string>;
+  getPubKey(): Promise<string>;
+  private signEvmTransaction;
+  private getWalletForAddress;
+  private getPublicClient;
+}
+//#endregion
+//#region src/strategy/TrezorBip32.d.ts
+declare class TrezorBip32 extends TrezorBase {
+  constructor(args: ConcreteEvmWalletStrategyArgs);
+}
+//#endregion
+//#region src/strategy/TrezorBip44.d.ts
+declare class TrezorBip44 extends TrezorBase {
+  constructor(args: ConcreteEvmWalletStrategyArgs);
+}
+//#endregion
+export { HDNodeLike, TrezorBip32 as TrezorBip32Strategy, TrezorBip44 as TrezorBip44Strategy, TrezorDerivationPathType, TrezorWalletInfo };

package/dist/cjs/package.json

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

package/dist/esm/index.d.ts

@@ -1,3 +1,72 @@
-export { TrezorBip32 as TrezorBip32Strategy } from './strategy/TrezorBip32.js';
-export { TrezorBip44 as TrezorBip44Strategy } from './strategy/TrezorBip44.js';
-export * from './types.js';
+import { BaseConcreteStrategy, ConcreteEvmWalletStrategyArgs, ConcreteWalletStrategy, SendTransactionOptions, StdSignDoc, WalletDeviceType } from "@injectivelabs/wallet-base";
+import { AminoSignResponse, DirectSignResponse, TxRaw, TxResponse } from "@injectivelabs/sdk-ts";
+import { AccountAddress, EvmChainId } from "@injectivelabs/ts-types";
+
+//#region src/types.d.ts
+interface HDNodeLike {
+  publicKey: Uint8Array;
+  chainCode: Uint8Array;
+}
+declare const TrezorDerivationPathType: {
+  readonly Bip32: "bip32";
+  readonly Bip44: "bip44";
+  readonly Legacy: "legacy";
+};
+type TrezorDerivationPathType = (typeof TrezorDerivationPathType)[keyof typeof TrezorDerivationPathType];
+interface TrezorWalletInfo {
+  address: string;
+  hdKey: HDNodeLike;
+  derivationPath: string;
+}
+//#endregion
+//#region src/strategy/Base.d.ts
+declare class TrezorBase extends BaseConcreteStrategy implements ConcreteWalletStrategy {
+  private baseDerivationPath;
+  private trezor;
+  private evmOptions;
+  private publicClient;
+  private derivationPathType;
+  constructor(args: ConcreteEvmWalletStrategyArgs & {
+    derivationPathType: TrezorDerivationPathType;
+  });
+  getWalletDeviceType(): Promise<WalletDeviceType>;
+  enable(): Promise<boolean>;
+  disconnect(): Promise<void>;
+  getAddresses(): Promise<string[]>;
+  getSessionOrConfirm(address: AccountAddress): Promise<string>;
+  sendEvmTransaction(txData: any, args: {
+    address: string;
+    evmChainId: EvmChainId;
+  }): Promise<string>;
+  sendTransaction(transaction: TxRaw, options: SendTransactionOptions): Promise<TxResponse>;
+  signEip712TypedData(eip712json: string, address: AccountAddress): Promise<string>;
+  signAminoCosmosTransaction(_transaction: {
+    address: string;
+    signDoc: StdSignDoc;
+  }): Promise<AminoSignResponse>;
+  signCosmosTransaction(_transaction: {
+    txRaw: TxRaw;
+    accountNumber: number;
+    chainId: string;
+    address: string;
+  }): Promise<DirectSignResponse>;
+  signArbitrary(signer: AccountAddress, data: string | Uint8Array): Promise<string>;
+  getEthereumChainId(): Promise<string>;
+  getEvmTransactionReceipt(txHash: string, evmChainId?: EvmChainId): Promise<string>;
+  getPubKey(): Promise<string>;
+  private signEvmTransaction;
+  private getWalletForAddress;
+  private getPublicClient;
+}
+//#endregion
+//#region src/strategy/TrezorBip32.d.ts
+declare class TrezorBip32 extends TrezorBase {
+  constructor(args: ConcreteEvmWalletStrategyArgs);
+}
+//#endregion
+//#region src/strategy/TrezorBip44.d.ts
+declare class TrezorBip44 extends TrezorBase {
+  constructor(args: ConcreteEvmWalletStrategyArgs);
+}
+//#endregion
+export { HDNodeLike, TrezorBip32 as TrezorBip32Strategy, TrezorBip44 as TrezorBip44Strategy, TrezorDerivationPathType, TrezorWalletInfo };