@injectivelabs/wallet-ledger 1.15.0 → 1.15.2

package/dist/cjs/strategy/LedgerCosmos/hw/index.d.ts

@@ -0,0 +1,11 @@
+import { Cosmos as CosmosApp } from '@bangjelkoski/ledgerhq-hw-app-cosmos';
+import { Transport } from '@bangjelkoski/ledgerhq-hw-transport';
+import AccountManager from './AccountManager.js';
+export default class LedgerTransport {
+    private ledger;
+    private accountManager;
+    protected static getTransport(): Promise<Transport>;
+    getInstance(): Promise<CosmosApp>;
+    getAccountManager(): Promise<AccountManager>;
+    refresh(): Promise<LedgerTransport>;
+}

package/dist/cjs/strategy/LedgerCosmos/hw/index.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ledgerhq_hw_transport_webusb_1 = require("@bangjelkoski/ledgerhq-hw-transport-webusb");
+const ledgerhq_hw_transport_webhid_1 = require("@bangjelkoski/ledgerhq-hw-transport-webhid");
+const ledgerhq_hw_app_cosmos_1 = require("@bangjelkoski/ledgerhq-hw-app-cosmos");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const AccountManager_js_1 = __importDefault(require("./AccountManager.js"));
+class LedgerTransport {
+    ledger = null;
+    accountManager = null;
+    static async getTransport() {
+        try {
+            if (await ledgerhq_hw_transport_webhid_1.TransportWebHID.isSupported()) {
+                return await ledgerhq_hw_transport_webhid_1.TransportWebHID.create();
+            }
+            if (await ledgerhq_hw_transport_webusb_1.TransportWebUSB.isSupported()) {
+                return await ledgerhq_hw_transport_webhid_1.TransportWebHID.create();
+            }
+        }
+        catch (e) {
+            throw new exceptions_1.LedgerCosmosException(new Error(e.message));
+        }
+        return await ledgerhq_hw_transport_webhid_1.TransportWebHID.create();
+    }
+    async getInstance() {
+        if (!this.ledger) {
+            this.ledger = new ledgerhq_hw_app_cosmos_1.Cosmos((await LedgerTransport.getTransport()));
+        }
+        return this.ledger;
+    }
+    async getAccountManager() {
+        if (!this.accountManager) {
+            this.accountManager = new AccountManager_js_1.default(await this.getInstance());
+        }
+        return this.accountManager;
+    }
+    async refresh() {
+        if (!this.ledger) {
+            return new LedgerTransport();
+        }
+        this.ledger.transport.close();
+        return new LedgerTransport();
+    }
+}
+exports.default = LedgerTransport;

package/dist/cjs/strategy/LedgerCosmos/index.d.ts

@@ -0,0 +1,36 @@
+import { ChainId, AccountAddress, EthereumChainId } from '@injectivelabs/ts-types';
+import { TxRaw, TxResponse, AminoSignResponse, DirectSignResponse } from '@injectivelabs/sdk-ts';
+import { StdSignDoc, WalletDeviceType, BaseConcreteStrategy, ConcreteWalletStrategy, SendTransactionOptions } from '@injectivelabs/wallet-base';
+export declare class LedgerCosmos extends BaseConcreteStrategy implements ConcreteWalletStrategy {
+    private baseDerivationPath;
+    private ledger;
+    constructor(args: {
+        chainId: ChainId;
+    });
+    getWalletDeviceType(): Promise<WalletDeviceType>;
+    enable(): Promise<boolean>;
+    disconnect(): Promise<void>;
+    getAddresses(): Promise<string[]>;
+    getSessionOrConfirm(address: AccountAddress): Promise<string>;
+    sendEthereumTransaction(_txData: any, _options: {
+        address: string;
+        ethereumChainId: EthereumChainId;
+    }): Promise<string>;
+    sendTransaction(transaction: TxRaw, options: SendTransactionOptions): Promise<TxResponse>;
+    signAminoCosmosTransaction(transaction: {
+        address: string;
+        signDoc: StdSignDoc;
+    }): Promise<AminoSignResponse>;
+    signCosmosTransaction(_transaction: {
+        txRaw: TxRaw;
+        accountNumber: number;
+        chainId: string;
+        address: string;
+    }): Promise<DirectSignResponse>;
+    signEip712TypedData(_eip712Json: string, _address: AccountAddress): Promise<string>;
+    signArbitrary(signer: AccountAddress, data: string | Uint8Array): Promise<string>;
+    getEthereumChainId(): Promise<string>;
+    getEthereumTransactionReceipt(_txHash: string): Promise<string>;
+    getPubKey(address?: string): Promise<string>;
+    private getWalletForAddress;
+}

package/dist/cjs/strategy/LedgerCosmos/index.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LedgerCosmos = void 0;
+const exceptions_1 = require("@injectivelabs/exceptions");
+const sdk_ts_1 = require("@injectivelabs/sdk-ts");
+const wallet_base_1 = require("@injectivelabs/wallet-base");
+const index_js_1 = __importDefault(require("./hw/index.js"));
+const exceptions_2 = require("@injectivelabs/exceptions");
+class LedgerCosmos extends wallet_base_1.BaseConcreteStrategy {
+    baseDerivationPath;
+    ledger;
+    constructor(args) {
+        super(args);
+        this.baseDerivationPath = wallet_base_1.DEFAULT_BASE_DERIVATION_PATH;
+        this.ledger = new index_js_1.default();
+    }
+    async getWalletDeviceType() {
+        return Promise.resolve(wallet_base_1.WalletDeviceType.Hardware);
+    }
+    async enable() {
+        return Promise.resolve(true);
+    }
+    async disconnect() {
+        this.ledger = await this.ledger.refresh();
+    }
+    async getAddresses() {
+        const { baseDerivationPath } = this;
+        try {
+            const accountManager = await this.ledger.getAccountManager();
+            const wallets = await accountManager.getWallets(baseDerivationPath);
+            return wallets.map((k) => k.address);
+        }
+        catch (e) {
+            throw new exceptions_1.LedgerCosmosException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: wallet_base_1.WalletAction.GetAccounts,
+            });
+        }
+    }
+    async getSessionOrConfirm(address) {
+        return Promise.resolve(`0x${Buffer.from(`Confirmation for ${address} at time: ${Date.now()}`).toString('hex')}`);
+    }
+    async sendEthereumTransaction(_txData, _options) {
+        throw new exceptions_2.CosmosWalletException(new Error('sendEthereumTransaction is not supported. LedgerCosmos only supports sending cosmos transactions'), {
+            code: exceptions_1.UnspecifiedErrorCode,
+            context: wallet_base_1.WalletAction.SendEthereumTransaction,
+        });
+    }
+    async sendTransaction(transaction, options) {
+        const { endpoints, txTimeout } = options;
+        if (!endpoints) {
+            throw new exceptions_1.WalletException(new Error('You have to pass endpoints.grpc within the options for using LedgerCosmos wallet'));
+        }
+        const txApi = new sdk_ts_1.TxGrpcApi(endpoints.grpc);
+        const response = await txApi.broadcast(transaction, { txTimeout });
+        if (response.code !== 0) {
+            throw new exceptions_1.TransactionException(new Error(response.rawLog), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                contextCode: response.code,
+                contextModule: response.codespace,
+            });
+        }
+        return response;
+    }
+    async signAminoCosmosTransaction(transaction) {
+        try {
+            const { derivationPath } = await this.getWalletForAddress(transaction.address);
+            const ledger = await this.ledger.getInstance();
+            const result = await ledger.sign(derivationPath, JSON.stringify((0, sdk_ts_1.sortObjectByKeys)(transaction.signDoc)));
+            return {
+                signed: undefined,
+                signature: {
+                    signature: Buffer.from(result.signature).toString('base64'),
+                    pub_key: undefined,
+                },
+            };
+        }
+        catch (e) {
+            throw new exceptions_1.LedgerCosmosException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: wallet_base_1.WalletAction.SignTransaction,
+            });
+        }
+    }
+    async signCosmosTransaction(_transaction) {
+        throw new exceptions_2.CosmosWalletException(new Error('This wallet does not support signing using direct sign'), {
+            code: exceptions_1.UnspecifiedErrorCode,
+            context: wallet_base_1.WalletAction.SendTransaction,
+        });
+    }
+    async signEip712TypedData(_eip712Json, _address) {
+        throw new exceptions_2.CosmosWalletException(new Error('This wallet does not support signing Ethereum transactions'), {
+            code: exceptions_1.UnspecifiedErrorCode,
+            context: wallet_base_1.WalletAction.SendTransaction,
+        });
+    }
+    async signArbitrary(signer, data) {
+        try {
+            const { derivationPath } = await this.getWalletForAddress(signer);
+            const ledger = await this.ledger.getInstance();
+            const result = await ledger.sign(derivationPath, (0, sdk_ts_1.toUtf8)(data));
+            return Buffer.from(result.signature).toString('base64');
+        }
+        catch (e) {
+            throw new exceptions_1.LedgerCosmosException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: wallet_base_1.WalletAction.SignTransaction,
+            });
+        }
+    }
+    async getEthereumChainId() {
+        throw new exceptions_2.CosmosWalletException(new Error('getEthereumChainId is not supported on Keplr'), {
+            code: exceptions_1.UnspecifiedErrorCode,
+            context: wallet_base_1.WalletAction.GetChainId,
+        });
+    }
+    async getEthereumTransactionReceipt(_txHash) {
+        throw new exceptions_2.CosmosWalletException(new Error('getEthereumTransactionReceipt is not supported on Keplr'), {
+            code: exceptions_1.UnspecifiedErrorCode,
+            context: wallet_base_1.WalletAction.GetEthereumTransactionReceipt,
+        });
+    }
+    async getPubKey(address) {
+        if (!address) {
+            throw new exceptions_1.WalletException(new Error('You can only fetch PubKey corresponding to an address'));
+        }
+        const ledgerWalletInfo = await this.getWalletForAddress(address);
+        return Buffer.from(ledgerWalletInfo.publicKey || '', 'hex').toString('base64');
+    }
+    async getWalletForAddress(address) {
+        try {
+            const { baseDerivationPath } = this;
+            const accountManager = await this.ledger.getAccountManager();
+            if (!accountManager.hasWalletForAddress(address)) {
+                for (let i = 0; i < wallet_base_1.DEFAULT_ADDRESS_SEARCH_LIMIT / wallet_base_1.DEFAULT_NUM_ADDRESSES_TO_FETCH; i += 1) {
+                    await accountManager.getWallets(baseDerivationPath);
+                    if (accountManager.hasWalletForAddress(address)) {
+                        return (await accountManager.getWalletForAddress(address));
+                    }
+                }
+            }
+            return (await accountManager.getWalletForAddress(address));
+        }
+        catch (e) {
+            throw new exceptions_1.LedgerCosmosException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: wallet_base_1.WalletAction.GetAccounts,
+            });
+        }
+    }
+}
+exports.LedgerCosmos = LedgerCosmos;

package/dist/cjs/types.d.ts

@@ -0,0 +1,17 @@
+import type HDNode from 'hdkey';
+export declare enum LedgerDerivationPathType {
+    LedgerLive = "ledger-live",
+    LedgerMew = "ledger-mew"
+}
+export interface LedgerWalletInfo {
+    address: string;
+    baseDerivationPath: string;
+    derivationPath: string;
+    hdKey?: HDNode;
+    publicKey?: string;
+}
+export declare enum WalletLedger {
+    Ledger = "ledger",
+    LedgerCosmos = "ledger-cosmos",
+    LedgerLegacy = "ledger-legacy"
+}

package/dist/cjs/types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletLedger = exports.LedgerDerivationPathType = void 0;
+var LedgerDerivationPathType;
+(function (LedgerDerivationPathType) {
+    LedgerDerivationPathType["LedgerLive"] = "ledger-live";
+    LedgerDerivationPathType["LedgerMew"] = "ledger-mew";
+})(LedgerDerivationPathType || (exports.LedgerDerivationPathType = LedgerDerivationPathType = {}));
+var WalletLedger;
+(function (WalletLedger) {
+    WalletLedger["Ledger"] = "ledger";
+    WalletLedger["LedgerCosmos"] = "ledger-cosmos";
+    WalletLedger["LedgerLegacy"] = "ledger-legacy";
+})(WalletLedger || (exports.WalletLedger = WalletLedger = {}));

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+export { LedgerLive as LedgerLiveStrategy } from './strategy/Ledger/LedgerLive.js';
+export { LedgerLegacy as LedgerLegacyStrategy } from './strategy/Ledger/LedgerLegacy.js';
+export { LedgerCosmos as LedgerCosmosStrategy } from './strategy/LedgerCosmos/index.js';
+export * from './types.js';

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+export { LedgerLive as LedgerLiveStrategy } from './strategy/Ledger/LedgerLive.js';
+export { LedgerLegacy as LedgerLegacyStrategy } from './strategy/Ledger/LedgerLegacy.js';
+export { LedgerCosmos as LedgerCosmosStrategy } from './strategy/LedgerCosmos/index.js';
+export * from './types.js';

package/dist/esm/package.json

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

package/dist/esm/strategy/Ledger/Base.d.ts

@@ -0,0 +1,42 @@
+import { AccountAddress, EthereumChainId } from '@injectivelabs/ts-types';
+import { TxRaw, TxResponse, DirectSignResponse, AminoSignResponse } from '@injectivelabs/sdk-ts';
+import { StdSignDoc, WalletDeviceType, BaseConcreteStrategy, SendTransactionOptions, ConcreteWalletStrategy, ConcreteEthereumWalletStrategyArgs } from '@injectivelabs/wallet-base';
+import { LedgerDerivationPathType } from '../../types.js';
+export default class LedgerBase extends BaseConcreteStrategy implements ConcreteWalletStrategy {
+    private baseDerivationPath;
+    private derivationPathType;
+    private ledger;
+    private ethereumOptions;
+    private alchemy;
+    constructor(args: ConcreteEthereumWalletStrategyArgs & {
+        derivationPathType: LedgerDerivationPathType;
+    });
+    getWalletDeviceType(): Promise<WalletDeviceType>;
+    enable(): Promise<boolean>;
+    disconnect(): Promise<void>;
+    getAddresses(): Promise<string[]>;
+    getSessionOrConfirm(address: AccountAddress): Promise<string>;
+    sendEthereumTransaction(txData: any, options: {
+        address: string;
+        ethereumChainId: EthereumChainId;
+    }): 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>;
+    getEthereumTransactionReceipt(txHash: string): Promise<string>;
+    getPubKey(): Promise<string>;
+    private signEthereumTransaction;
+    private getWalletForAddress;
+    private getAlchemy;
+}

package/dist/esm/strategy/Ledger/Base.js

@@ -0,0 +1,239 @@
+/* eslint-disable class-methods-use-this */
+import { EthereumChainId } from '@injectivelabs/ts-types';
+import { bufferToHex, addHexPrefix } from 'ethereumjs-util';
+import { Common, Chain, Hardfork } from '@ethereumjs/common';
+import { FeeMarketEIP1559Transaction } from '@ethereumjs/tx';
+import { ledgerService } from '@bangjelkoski/ledgerhq-hw-app-eth';
+import { ErrorType, GeneralException, LedgerException, TransactionException, UnspecifiedErrorCode, WalletException, } from '@injectivelabs/exceptions';
+import { toUtf8, TxGrpcApi, } from '@injectivelabs/sdk-ts';
+import { TIP_IN_GWEI, WalletAction, WalletDeviceType, getKeyFromRpcUrl, BaseConcreteStrategy, DEFAULT_BASE_DERIVATION_PATH, DEFAULT_ADDRESS_SEARCH_LIMIT, DEFAULT_NUM_ADDRESSES_TO_FETCH, } from '@injectivelabs/wallet-base';
+import LedgerHW from './hw/index.js';
+import { domainHash, messageHash } from './utils.js';
+import { Alchemy, Network as AlchemyNetwork } from 'alchemy-sdk';
+const getNetworkFromChainId = (chainId) => {
+    if (chainId === EthereumChainId.Goerli) {
+        return Chain.Goerli;
+    }
+    if (chainId === EthereumChainId.Sepolia) {
+        return Chain.Sepolia;
+    }
+    if (chainId === EthereumChainId.Kovan) {
+        return Chain.Goerli;
+    }
+    return Chain.Mainnet;
+};
+export default class LedgerBase extends BaseConcreteStrategy {
+    baseDerivationPath;
+    derivationPathType;
+    ledger;
+    ethereumOptions;
+    alchemy;
+    constructor(args) {
+        super(args);
+        this.baseDerivationPath = DEFAULT_BASE_DERIVATION_PATH;
+        this.derivationPathType = args.derivationPathType;
+        this.ledger = new LedgerHW();
+        this.ethereumOptions = args.ethereumOptions;
+    }
+    async getWalletDeviceType() {
+        return Promise.resolve(WalletDeviceType.Hardware);
+    }
+    async enable() {
+        return Promise.resolve(true);
+    }
+    async disconnect() {
+        this.ledger = await this.ledger.refresh();
+    }
+    async getAddresses() {
+        const { baseDerivationPath, derivationPathType } = this;
+        try {
+            const accountManager = await this.ledger.getAccountManager();
+            const wallets = await accountManager.getWallets(baseDerivationPath, derivationPathType);
+            return wallets.map((k) => k.address);
+        }
+        catch (e) {
+            throw new LedgerException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: WalletAction.GetAccounts,
+            });
+        }
+    }
+    async getSessionOrConfirm(address) {
+        return Promise.resolve(`0x${Buffer.from(`Confirmation for ${address} at time: ${Date.now()}`).toString('hex')}`);
+    }
+    async sendEthereumTransaction(txData, options) {
+        const signedTransaction = await this.signEthereumTransaction(txData, options);
+        try {
+            const alchemy = await this.getAlchemy();
+            const txReceipt = await alchemy.core.sendTransaction(addHexPrefix(signedTransaction.serialize().toString('hex')));
+            return txReceipt.hash;
+        }
+        catch (e) {
+            throw new LedgerException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: WalletAction.SendEthereumTransaction,
+            });
+        }
+    }
+    async sendTransaction(transaction, options) {
+        const { endpoints, txTimeout } = options;
+        if (!endpoints) {
+            throw new WalletException(new Error('You have to pass endpoints.grpc within the options for using Ethereum native wallets'));
+        }
+        const txApi = new TxGrpcApi(endpoints.grpc);
+        const response = await txApi.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 { derivationPath } = await this.getWalletForAddress(address);
+        const object = JSON.parse(eip712json);
+        try {
+            const ledger = await this.ledger.getInstance();
+            const result = await ledger.signEIP712HashedMessage(derivationPath, bufferToHex(domainHash(object)), bufferToHex(messageHash(object)));
+            const combined = `${result.r}${result.s}${result.v.toString(16)}`;
+            return combined.startsWith('0x') ? combined : `0x${combined}`;
+        }
+        catch (e) {
+            throw new LedgerException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: WalletAction.SignTransaction,
+            });
+        }
+    }
+    async signAminoCosmosTransaction(_transaction) {
+        throw new WalletException(new Error('This wallet does not support signing Cosmos transactions'), {
+            code: UnspecifiedErrorCode,
+            type: ErrorType.WalletError,
+            contextModule: WalletAction.SendTransaction,
+        });
+    }
+    // eslint-disable-next-line class-methods-use-this
+    async signCosmosTransaction(_transaction) {
+        throw new WalletException(new Error('This wallet does not support signing Cosmos transactions'), {
+            code: UnspecifiedErrorCode,
+            type: ErrorType.WalletError,
+            contextModule: WalletAction.SendTransaction,
+        });
+    }
+    async signArbitrary(signer, data) {
+        try {
+            const { derivationPath } = await this.getWalletForAddress(signer);
+            const ledger = await this.ledger.getInstance();
+            const result = await ledger.signPersonalMessage(derivationPath, Buffer.from(toUtf8(data), 'utf8').toString('hex'));
+            const combined = `${result.r}${result.s}${result.v.toString(16)}`;
+            return combined.startsWith('0x') ? combined : `0x${combined}`;
+        }
+        catch (e) {
+            throw new LedgerException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: WalletAction.SignTransaction,
+            });
+        }
+    }
+    async getEthereumChainId() {
+        const alchemy = await this.getAlchemy();
+        const alchemyProvider = await alchemy.config.getProvider();
+        return alchemyProvider.network.chainId.toString();
+    }
+    async getEthereumTransactionReceipt(txHash) {
+        return Promise.resolve(txHash);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    async getPubKey() {
+        throw new WalletException(new Error('You can only fetch PubKey from Cosmos native wallets'));
+    }
+    async signEthereumTransaction(txData, options) {
+        const alchemy = await this.getAlchemy();
+        const chainId = parseInt(options.ethereumChainId.toString(), 10);
+        const nonce = await alchemy.core.getTransactionCount(options.address);
+        const common = new Common({
+            chain: getNetworkFromChainId(chainId),
+            hardfork: Hardfork.London,
+        });
+        const eip1559TxData = {
+            from: txData.from,
+            data: txData.data,
+            to: txData.to,
+            nonce: addHexPrefix(nonce.toString(16)),
+            gas: addHexPrefix(txData.gas),
+            gasLimit: addHexPrefix(txData.gas),
+            maxFeePerGas: addHexPrefix(txData.gasPrice || txData.maxFeePerGas),
+            maxPriorityFeePerGas: addHexPrefix(txData.maxPriorityFeePerGas || TIP_IN_GWEI.toString(16)),
+        };
+        const tx = FeeMarketEIP1559Transaction.fromTxData(eip1559TxData, { common });
+        const msg = tx.getMessageToSign(false);
+        // const encodedMessage = msg
+        const encodedMessageHex = msg.toString('hex');
+        try {
+            const ledger = await this.ledger.getInstance();
+            const { derivationPath } = await this.getWalletForAddress(options.address);
+            const resolution = await ledgerService.resolveTransaction(encodedMessageHex, {}, {});
+            const txSig = await ledger.signTransaction(derivationPath, encodedMessageHex, resolution);
+            const signedTxData = {
+                ...eip1559TxData,
+                v: `0x${txSig.v}`,
+                r: `0x${txSig.r}`,
+                s: `0x${txSig.s}`,
+            };
+            return FeeMarketEIP1559Transaction.fromTxData(signedTxData, {
+                common,
+            });
+        }
+        catch (e) {
+            throw new LedgerException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: WalletAction.SignEthereumTransaction,
+            });
+        }
+    }
+    async getWalletForAddress(address) {
+        try {
+            const { baseDerivationPath, derivationPathType } = this;
+            const accountManager = await this.ledger.getAccountManager();
+            if (!accountManager.hasWalletForAddress(address)) {
+                for (let i = 0; i < DEFAULT_ADDRESS_SEARCH_LIMIT / 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));
+        }
+        catch (e) {
+            throw new LedgerException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: WalletAction.GetAccounts,
+            });
+        }
+    }
+    async getAlchemy() {
+        if (this.alchemy) {
+            return this.alchemy;
+        }
+        const { rpcUrl, ethereumChainId } = this.ethereumOptions;
+        if (!rpcUrl) {
+            throw new GeneralException(new Error('Please pass rpcUrl within the ethereumOptions'));
+        }
+        this.alchemy = new Alchemy({
+            apiKey: getKeyFromRpcUrl(rpcUrl),
+            network: ethereumChainId === EthereumChainId.Mainnet
+                ? AlchemyNetwork.ETH_MAINNET
+                : AlchemyNetwork.ETH_SEPOLIA,
+        });
+        return this.alchemy;
+    }
+}

package/dist/esm/strategy/Ledger/LedgerLegacy.d.ts

@@ -0,0 +1,5 @@
+import { ConcreteEthereumWalletStrategyArgs } from '@injectivelabs/wallet-base';
+import LedgerBase from './Base.js';
+export declare class LedgerLegacy extends LedgerBase {
+    constructor(args: ConcreteEthereumWalletStrategyArgs);
+}

package/dist/esm/strategy/Ledger/LedgerLegacy.js

@@ -0,0 +1,10 @@
+import { LedgerDerivationPathType } from '../../types.js';
+import LedgerBase from './Base.js';
+export class LedgerLegacy extends LedgerBase {
+    constructor(args) {
+        super({
+            ...args,
+            derivationPathType: LedgerDerivationPathType.LedgerMew,
+        });
+    }
+}

package/dist/esm/strategy/Ledger/LedgerLive.d.ts

@@ -0,0 +1,5 @@
+import { ConcreteEthereumWalletStrategyArgs } from '@injectivelabs/wallet-base';
+import LedgerBase from './Base.js';
+export declare class LedgerLive extends LedgerBase {
+    constructor(args: ConcreteEthereumWalletStrategyArgs);
+}

package/dist/esm/strategy/Ledger/LedgerLive.js

@@ -0,0 +1,10 @@
+import { LedgerDerivationPathType } from '../../types.js';
+import LedgerBase from './Base.js';
+export class LedgerLive extends LedgerBase {
+    constructor(args) {
+        super({
+            ...args,
+            derivationPathType: LedgerDerivationPathType.LedgerLive,
+        });
+    }
+}

package/dist/esm/strategy/Ledger/hw/AccountManager.d.ts

@@ -0,0 +1,21 @@
+import { AccountAddress } from '@injectivelabs/ts-types';
+import { Eth as EthereumApp } from '@bangjelkoski/ledgerhq-hw-app-eth';
+import { LedgerDerivationPathType, LedgerWalletInfo } from '../../../types.js';
+export default class AccountManager {
+    private wallets;
+    private ledger;
+    constructor(ledger: EthereumApp);
+    getWallets(baseDerivationPath: string, derivationPathType: LedgerDerivationPathType): Promise<LedgerWalletInfo[]>;
+    getLedgerDerivationPathBasedOnType: ({ fullBaseDerivationPath, derivationPathType, index, }: {
+        fullBaseDerivationPath: string;
+        derivationPathType: LedgerDerivationPathType;
+        index: number;
+    }) => string;
+    private getWalletsBasedOnIndex;
+    private hasWallets;
+    private hasWalletsInOffset;
+    private getOffset;
+    hasWalletForAddress(address: AccountAddress): boolean;
+    getWalletForAddress(address: AccountAddress): Promise<LedgerWalletInfo | undefined>;
+    reset(): void;
+}