@injectivelabs/wallet-ledger 1.16.25-alpha.0 → 1.16.25

package/dist/cjs/index.d.ts

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

package/dist/cjs/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LedgerLegacyStrategy = exports.LedgerCosmosStrategy = exports.LedgerLiveStrategy = void 0;
+var LedgerLive_js_1 = require("./strategy/Ledger/LedgerLive.js");
+Object.defineProperty(exports, "LedgerLiveStrategy", { enumerable: true, get: function () { return LedgerLive_js_1.LedgerLive; } });
+var index_js_1 = require("./strategy/LedgerCosmos/index.js");
+Object.defineProperty(exports, "LedgerCosmosStrategy", { enumerable: true, get: function () { return index_js_1.LedgerCosmos; } });
+var LedgerLegacy_js_1 = require("./strategy/Ledger/LedgerLegacy.js");
+Object.defineProperty(exports, "LedgerLegacyStrategy", { enumerable: true, get: function () { return LedgerLegacy_js_1.LedgerLegacy; } });
+__exportStar(require("./types.js"), exports);

package/dist/cjs/package.json

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

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

@@ -0,0 +1,45 @@
+import { EvmChainId } from '@injectivelabs/ts-types';
+import { WalletDeviceType, BaseConcreteStrategy } from '@injectivelabs/wallet-base';
+import type { AccountAddress } from '@injectivelabs/ts-types';
+import type { LedgerDerivationPathType } from '../../types.js';
+import type { TxRaw, TxResponse, AminoSignResponse, DirectSignResponse } from '@injectivelabs/sdk-ts';
+import type { StdSignDoc, Eip1193Provider, SendTransactionOptions, ConcreteWalletStrategy, ConcreteEvmWalletStrategyArgs } from '@injectivelabs/wallet-base';
+export default class LedgerBase extends BaseConcreteStrategy implements ConcreteWalletStrategy {
+    private baseDerivationPath;
+    private derivationPathType;
+    private ledger;
+    private evmOptions;
+    private alchemy;
+    constructor(args: ConcreteEvmWalletStrategyArgs & {
+        derivationPathType: LedgerDerivationPathType;
+    });
+    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;
+    getEip1193Provider(): Promise<Eip1193Provider>;
+    private getAlchemy;
+}

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

@@ -0,0 +1,283 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const utils_1 = require("@injectivelabs/utils");
+const ts_types_1 = require("@injectivelabs/ts-types");
+const sdk_ts_1 = require("@injectivelabs/sdk-ts");
+const alchemy_sdk_1 = require("alchemy-sdk");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const wallet_base_1 = require("@injectivelabs/wallet-base");
+const index_js_1 = __importDefault(require("./hw/index.js"));
+const lib_js_1 = require("./../lib.js");
+const utils_js_1 = require("./utils.js");
+const Eip1193Provider_js_1 = require("./Eip1193Provider.js");
+class LedgerBase extends wallet_base_1.BaseConcreteStrategy {
+    baseDerivationPath;
+    derivationPathType;
+    ledger;
+    evmOptions;
+    alchemy;
+    constructor(args) {
+        super(args);
+        this.baseDerivationPath = wallet_base_1.DEFAULT_BASE_DERIVATION_PATH;
+        this.derivationPathType = args.derivationPathType;
+        this.ledger = new index_js_1.default();
+        this.evmOptions = args.evmOptions;
+    }
+    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, 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 exceptions_1.LedgerException(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 sendEvmTransaction(txData, args) {
+        const signedTransaction = await this.signEvmTransaction(txData, args);
+        try {
+            const alchemy = await this.getAlchemy(args.evmChainId);
+            const provider = await alchemy.config.getProvider();
+            const txHash = await provider.send('eth_sendRawTransaction', [
+                signedTransaction,
+            ]);
+            return txHash;
+        }
+        catch (e) {
+            throw new exceptions_1.LedgerException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: wallet_base_1.WalletAction.SendEvmTransaction,
+            });
+        }
+    }
+    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 Ethereum native wallets'));
+        }
+        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 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.signEIP712Message(derivationPath, object);
+            const combined = `${result.r}${result.s}${result.v.toString(16)}`;
+            return combined.startsWith('0x') ? combined : `0x${combined}`;
+        }
+        catch (e) {
+            const errorMessage = e.message;
+            const isKnownNanoSError = errorMessage.includes('instruction not supported') ||
+                errorMessage.includes('invalid status') ||
+                errorMessage.includes('not supported') ||
+                errorMessage.includes('INS_NOT_SUPPORTED');
+            if (!isKnownNanoSError) {
+                throw new exceptions_1.LedgerException(new Error(errorMessage), {
+                    code: exceptions_1.UnspecifiedErrorCode,
+                    type: exceptions_1.ErrorType.WalletError,
+                    contextModule: wallet_base_1.WalletAction.SignTransaction,
+                });
+            }
+            try {
+                const ledger = await this.ledger.getInstance();
+                const result = await ledger.signEIP712HashedMessage(derivationPath, (0, utils_js_1.domainHash)(object), (0, utils_js_1.messageHash)(object));
+                const combined = `${result.r}${result.s}${result.v.toString(16)}`;
+                return combined.startsWith('0x') ? combined : `0x${combined}`;
+            }
+            catch (e) {
+                throw new exceptions_1.LedgerException(new Error(e.message), {
+                    code: exceptions_1.UnspecifiedErrorCode,
+                    type: exceptions_1.ErrorType.WalletError,
+                    contextModule: wallet_base_1.WalletAction.SignTransaction,
+                });
+            }
+        }
+    }
+    async signAminoCosmosTransaction(_transaction) {
+        throw new exceptions_1.WalletException(new Error('This wallet does not support signing Cosmos transactions'), {
+            code: exceptions_1.UnspecifiedErrorCode,
+            type: exceptions_1.ErrorType.WalletError,
+            contextModule: wallet_base_1.WalletAction.SendTransaction,
+        });
+    }
+    async signCosmosTransaction(_transaction) {
+        throw new exceptions_1.WalletException(new Error('This wallet does not support signing Cosmos transactions'), {
+            code: exceptions_1.UnspecifiedErrorCode,
+            type: exceptions_1.ErrorType.WalletError,
+            contextModule: 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.signPersonalMessage(derivationPath, Buffer.from((0, sdk_ts_1.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 exceptions_1.LedgerException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: wallet_base_1.WalletAction.SignTransaction,
+            });
+        }
+    }
+    async getEthereumChainId() {
+        const alchemy = await this.getAlchemy();
+        const alchemyProvider = await alchemy.config.getProvider();
+        return alchemyProvider.network.chainId.toString();
+    }
+    async getEvmTransactionReceipt(txHash, evmChainId) {
+        const alchemy = await this.getAlchemy(evmChainId);
+        const provider = await alchemy.config.getProvider();
+        const interval = 3000;
+        const maxAttempts = 10;
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            attempts++;
+            await (0, utils_1.sleep)(interval);
+            try {
+                const receipt = await provider.send('eth_getTransactionReceipt', [
+                    txHash,
+                ]);
+                if (receipt) {
+                    return txHash;
+                }
+            }
+            catch { }
+        }
+        throw new Error(`Failed to retrieve transaction receipt for txHash: ${txHash}`);
+    }
+    async getPubKey() {
+        throw new exceptions_1.WalletException(new Error('You can only fetch PubKey from Cosmos native wallets'));
+    }
+    async signEvmTransaction(txData, args) {
+        const ledgerService = await (0, lib_js_1.loadLedgerServiceType)();
+        const alchemy = await this.getAlchemy(args.evmChainId);
+        const chainId = parseInt(args.evmChainId.toString(), 10);
+        const nonce = await alchemy.core.getTransactionCount(args.address);
+        const parseHexValue = (value) => {
+            if (typeof value === 'string') {
+                const hexValue = value.startsWith('0x') ? value : `0x${value}`;
+                return BigInt(hexValue);
+            }
+            return BigInt(value);
+        };
+        const eip1559TxData = {
+            type: 'eip1559',
+            chainId,
+            nonce,
+            to: txData.to,
+            value: parseHexValue(txData.value || '0x0'),
+            data: txData.data,
+            gas: parseHexValue(txData.gas),
+            maxFeePerGas: parseHexValue(txData.maxFeePerGas),
+            maxPriorityFeePerGas: parseHexValue(txData.maxPriorityFeePerGas),
+        };
+        // Serialize the transaction
+        const serializedTx = (0, viem_1.serializeTransaction)(eip1559TxData);
+        const serializedTxHex = serializedTx.slice(2); // Remove 0x prefix
+        try {
+            const ledger = await this.ledger.getInstance();
+            const { derivationPath } = await this.getWalletForAddress(args.address);
+            // Resolve transaction for Ledger display
+            const resolution = await ledgerService.resolveTransaction(serializedTxHex, {}, {});
+            // Sign the transaction with Ledger
+            const txSig = await ledger.signTransaction(derivationPath, serializedTxHex, resolution);
+            const signedTxData = {
+                ...eip1559TxData,
+                v: BigInt(`0x${txSig.v}`),
+                r: `0x${txSig.r}`,
+                s: `0x${txSig.s}`,
+            };
+            return (0, viem_1.serializeTransaction)(signedTxData);
+        }
+        catch (e) {
+            throw new exceptions_1.LedgerException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: wallet_base_1.WalletAction.SignEvmTransaction,
+            });
+        }
+    }
+    async getWalletForAddress(address) {
+        try {
+            const { baseDerivationPath, derivationPathType } = 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, derivationPathType);
+                    if (accountManager.hasWalletForAddress(address)) {
+                        return (await accountManager.getWalletForAddress(address));
+                    }
+                }
+            }
+            return (await accountManager.getWalletForAddress(address));
+        }
+        catch (e) {
+            throw new exceptions_1.LedgerException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: wallet_base_1.WalletAction.GetAccounts,
+            });
+        }
+    }
+    async getEip1193Provider() {
+        return new Eip1193Provider_js_1.LedgerEip1193Provider(this.ledger, {
+            chainId: this.evmOptions.evmChainId.toString(),
+            derivationPath: this.baseDerivationPath,
+        });
+    }
+    async getAlchemy(evmChainId) {
+        if (this.alchemy) {
+            return this.alchemy;
+        }
+        const options = this.evmOptions;
+        const chainId = evmChainId || options.evmChainId;
+        const url = options.rpcUrl || options.rpcUrls?.[chainId];
+        if (!url) {
+            throw new exceptions_1.GeneralException(new Error('Please pass rpcUrl within the evmOptions'));
+        }
+        this.alchemy = new alchemy_sdk_1.Alchemy({
+            apiKey: (0, wallet_base_1.getKeyFromRpcUrl)(url),
+            network: chainId === ts_types_1.EvmChainId.Mainnet
+                ? alchemy_sdk_1.Network.ETH_MAINNET
+                : alchemy_sdk_1.Network.ETH_SEPOLIA,
+        });
+        return this.alchemy;
+    }
+}
+exports.default = LedgerBase;