@sidhujag/sysweb3-keyring 1.0.628 → 2.1.0

package/cjs/ledger/index.js

@@ -1,475 +1,271 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LedgerKeyring = void 0;
-const bitcoin_client_1 = __importStar(require("./bitcoin_client"));
-const consts_1 = require("./consts");
-const sysweb3_network_1 = require("@sidhujag/sysweb3-network");
-const bip32_1 = __importDefault(require("bip32"));
-const secp256k1_1 = __importDefault(require("@bitcoinerlab/secp256k1"));
-const hw_app_eth_1 = __importStar(require("@ledgerhq/hw-app-eth"));
-const syscoinjs_lib_1 = require("syscoinjs-lib");
 const eth_sig_util_1 = require("@metamask/eth-sig-util");
-const derivation_paths_1 = require("../utils/derivation-paths");
+const ethers_1 = require("ethers");
 const hardware_wallet_manager_1 = require("../hardware-wallet-manager");
-//
+const host_types_1 = require("./host-types");
+const invalidRequest = () => (0, host_types_1.ledgerHostError)('LEDGER_INVALID_REQUEST', 'Invalid Ledger signing request');
+const invalidSignature = () => (0, host_types_1.ledgerHostError)('LEDGER_INVALID_SIGNATURE', 'Ledger returned an invalid signature for this request');
+const accountIndex = (value) => {
+    if (!Number.isSafeInteger(value) || value < 0 || value > 0x7fffffff)
+        throw invalidRequest();
+    return value;
+};
+const hexBytes = (value) => {
+    if (typeof value !== 'string' || !/^(?:0x)?(?:[0-9a-f]{2})*$/i.test(value))
+        throw invalidRequest();
+    return Uint8Array.from(Buffer.from(value.replace(/^0x/i, ''), 'hex'));
+};
+const approvedAddress = (value) => {
+    try {
+        return (0, ethers_1.getAddress)(value);
+    }
+    catch {
+        throw invalidRequest();
+    }
+};
+const checkedSignature = (value, digest, expected) => {
+    try {
+        let signature;
+        if (typeof value === 'string') {
+            if (!/^0x[0-9a-f]{130}$/i.test(value))
+                throw invalidSignature();
+            signature = ethers_1.Signature.from(value);
+        }
+        else {
+            if (!value ||
+                !/^[0-9a-f]{64}$/i.test(value.r) ||
+                !/^[0-9a-f]{64}$/i.test(value.s) ||
+                !/^[0-9a-f]+$/i.test(value.v))
+                throw invalidSignature();
+            const v = Number.parseInt(value.v, 16);
+            if (!Number.isSafeInteger(v) || v < 0)
+                throw invalidSignature();
+            signature = ethers_1.Signature.from({ r: `0x${value.r}`, s: `0x${value.s}`, v });
+        }
+        if ((0, ethers_1.recoverAddress)(digest, signature) !== expected)
+            throw invalidSignature();
+        return signature;
+    }
+    catch {
+        throw invalidSignature();
+    }
+};
+// Detach the approved typed data before connection or host code can await/mutate it.
+const copyTypedData = (value, seen = new WeakSet(), depth = 0) => {
+    if (depth > 64)
+        throw invalidRequest();
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'bigint')
+        return value.toString();
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            throw invalidRequest();
+        return value;
+    }
+    if (value instanceof Uint8Array)
+        return `0x${Buffer.from(value).toString('hex')}`;
+    if (!value || typeof value !== 'object' || seen.has(value))
+        throw invalidRequest();
+    const array = Array.isArray(value);
+    const prototype = Object.getPrototypeOf(value);
+    if (!array && prototype !== Object.prototype && prototype !== null)
+        throw invalidRequest();
+    seen.add(value);
+    try {
+        const result = array ? [] : Object.create(null);
+        for (const key of Object.keys(value)) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!('value' in descriptor))
+                throw invalidRequest();
+            if (descriptor.value !== undefined)
+                result[key] = copyTypedData(descriptor.value, seen, depth + 1);
+        }
+        return Object.freeze(result);
+    }
+    finally {
+        seen.delete(value);
+    }
+};
+/** Small authority-side facade. Device SDKs belong exclusively in ledger-host. */
 class LedgerKeyring {
-    /**
-     * @param sharedHardwareWalletManager Optional shared HardwareWalletManager instance.
-     *                                     If provided, this will be used instead of creating
-     *                                     a new instance. This allows multiple KeyringManagers
-     *                                     to share the same Ledger connection.
-     */
-    constructor(sharedHardwareWalletManager) {
-        this.hdPath = "m/44'/57'/0'/0/0";
-        this.transport = null;
-        // In-memory cache of registered wallet policy HMACs
-        this.walletHmacCache = new Map();
-        this.getUtxoAddress = async ({ coin, index, // account index
-        slip44, showInLedger, }) => {
-            return this.executeWithRetry(async () => {
-                const fingerprint = await this.ledgerUtxoClient.getMasterFingerprint();
-                const xpub = await this.getXpub({ index, coin, slip44 });
-                this.setHdPath(coin, index, slip44);
-                // xpub/tpub already comes from device; no conversion needed here
-                const xpubWithDescriptor = `[${this.hdPath}]${xpub}`.replace('m', fingerprint);
-                const walletPolicy = new bitcoin_client_1.WalletPolicy(coin, consts_1.DESCRIPTOR, [
-                    xpubWithDescriptor,
-                ]);
-                const hmac = await this.getOrRegisterHmac(walletPolicy, fingerprint);
-                const address = await this.ledgerUtxoClient.getWalletAddress(walletPolicy, hmac, consts_1.RECEIVING_ADDRESS_INDEX, 0, // verify imported account address at first receive index
-                !!showInLedger);
-                return address;
-            }, 'getUtxoAddress');
+    // Retain the first constructor position for existing shared-manager callers.
+    // A manager alone cannot grant a new device capability.
+    constructor(sharedHardwareWalletManager, host) {
+        this.sharedHardwareWalletManager = sharedHardwareWalletManager;
+        this.host = host;
+        this.generation = 0;
+        this.ensureConnection = async () => this.run(async () => undefined);
+        this.verifyUtxoAddress = (accountIndex, currency, slip44) => this.run((host) => host.utxo.getAddress({
+            accountIndex,
+            currency,
+            slip44,
+            checkOnDevice: true,
+        }));
+        this.signUtxoMessage = (request) => {
+            const approved = Object.freeze({
+                currency: request.currency,
+                slip44: request.slip44,
+                accountIndex: request.accountIndex,
+                message: request.message,
+                addressIndex: request.addressIndex,
+                change: request.change,
+                accountXpub: request.accountXpub,
+            });
+            return this.run((host) => host.utxo.signMessage(approved));
         };
-        this.verifyUtxoAddress = async (accountIndex, currency, slip44) => await this.getUtxoAddress({
-            coin: currency,
-            index: accountIndex,
-            slip44: slip44,
-            showInLedger: true,
-        });
-        this.getXpub = async ({ index, coin, slip44, }) => {
-            return this.executeWithRetry(async () => {
-                this.setHdPath(coin, index, slip44);
-                {
-                    // Try silent first, then fall back to on-device display for unusual paths
+        this.signPsbt = (request) => {
+            const approved = Object.freeze({
+                currency: request.currency,
+                slip44: request.slip44,
+                accountIndex: request.accountIndex,
+                accountXpub: request.accountXpub,
+                psbtBase64: request.psbtBase64,
+            });
+            return this.run((host) => host.utxo.signPsbt(approved));
+        };
+        this.evm = {
+            getEvmAddressAndPubKey: async (request) => {
+                const approved = { accountIndex: accountIndex(request.accountIndex) };
+                return this.run(async (host, assertCurrent) => {
+                    const result = await host.evm.getAddress(approved);
+                    assertCurrent();
                     try {
-                        return await this.ledgerUtxoClient.getExtendedPubkey(this.hdPath, consts_1.WILL_NOT_DISPLAY);
+                        const address = (0, ethers_1.getAddress)(result.address);
+                        const publicKey = result.publicKey.replace(/^0x/i, '');
+                        if ((0, ethers_1.computeAddress)(`0x${publicKey}`) !== address)
+                            throw invalidRequest();
+                        return { address, publicKey };
                     }
-                    catch (err) {
-                        // Retry with display=true to allow unusual paths with user approval
-                        return await this.ledgerUtxoClient.getExtendedPubkey(this.hdPath, true);
+                    catch {
+                        throw (0, host_types_1.ledgerHostError)('LEDGER_INVALID_RESPONSE', 'Ledger returned an invalid address or public key');
                     }
+                });
+            },
+            signEVMTransaction: async (request) => {
+                const index = accountIndex(request.accountIndex);
+                const expected = approvedAddress(request.expectedAddress);
+                let transaction;
+                try {
+                    transaction = ethers_1.Transaction.from(`0x${Buffer.from(hexBytes(request.rawTx)).toString('hex')}`);
+                    if (transaction.signature || transaction.chainId <= 0n)
+                        throw invalidRequest();
                 }
-            }, 'getXpub');
-        };
-        /**
-         * Sign a UTXO message - public method used by transaction classes
-         */
-        this.signUtxoMessage = async (path, message) => {
-            return this.executeWithRetry(async () => {
-                const bufferMessage = Buffer.from(message);
-                const signature = await this.ledgerUtxoClient.signMessage(bufferMessage, path);
-                return signature;
-            }, 'signUtxoMessage');
-        };
-        this.signEVMTransaction = async ({ rawTx, accountIndex, }) => {
-            return this.executeWithRetry(async () => {
-                this.setHdPath('eth', accountIndex, 60);
-                const resolution = await hw_app_eth_1.ledgerService.resolveTransaction(rawTx, {}, {});
-                const signature = await this.ledgerEVMClient.signTransaction(this.hdPath.replace(/^m\//, ''), // Remove 'm/' prefix for EVM
-                rawTx, resolution);
-                return signature;
-            }, 'signEVMTransaction');
-        };
-        this.signPersonalMessage = async ({ message, accountIndex, }) => {
-            return this.executeWithRetry(async () => {
-                this.setHdPath('eth', accountIndex, 60);
-                const signature = await this.ledgerEVMClient.signPersonalMessage(this.hdPath.replace(/^m\//, ''), // Remove 'm/' prefix for EVM
-                message);
-                return `0x${signature.r}${signature.s}${signature.v.toString(16)}`;
-            }, 'signPersonalMessage');
-        };
-        this.transformTypedData = (data, version) => {
-            const { types, primaryType, domain, message } = this.sanitizeData(data);
-            const domainSeparatorHash = eth_sig_util_1.TypedDataUtils.hashStruct('EIP712Domain', this.sanitizeData(domain), types, version).toString('hex');
-            let messageHash = null;
-            if (primaryType !== 'EIP712Domain') {
-                messageHash = eth_sig_util_1.TypedDataUtils.hashStruct(primaryType, this.sanitizeData(message), types, version).toString('hex');
-            }
-            return {
-                domain_separator_hash: domainSeparatorHash,
-                message_hash: messageHash,
-                ...data,
-            };
-        };
-        this.getEvmAddressAndPubKey = async ({ accountIndex, }) => {
-            return this.executeWithRetry(async () => {
-                this.setHdPath('eth', accountIndex, 60);
-                const { address, publicKey } = await this.ledgerEVMClient.getAddress(this.hdPath.replace(/^m\//, '') // Remove 'm/' prefix for EVM
-                );
-                return { address, publicKey };
-            }, 'getEvmAddressAndPubKey');
-        };
-        this.signTypedData = async ({ version, data, accountIndex, }) => {
-            return this.executeWithRetry(async () => {
-                this.setHdPath('eth', accountIndex, 60);
-                // V1 typed data is not supported by hardware wallets
-                if (version === eth_sig_util_1.SignTypedDataVersion.V1) {
-                    throw new Error('Ledger: V1 typed data signing is not supported. Please use V3 or V4.');
+                catch {
+                    throw invalidRequest();
                 }
-                const dataWithHashes = this.transformTypedData(data, version);
-                const { domain_separator_hash, message_hash } = dataWithHashes;
-                const signature = await this.ledgerEVMClient.signEIP712HashedMessage(this.hdPath.replace(/^m\//, ''), // Remove 'm/' prefix for EVM
-                domain_separator_hash, message_hash ? message_hash : '');
-                return `0x${signature.r}${signature.s}${signature.v.toString(16)}`;
-            }, 'signTypedData');
-        };
-        this.getMasterFingerprint = async () => {
-            try {
-                const masterFingerprint = await this.ledgerUtxoClient.getMasterFingerprint();
-                return masterFingerprint;
-            }
-            catch (error) {
-                console.log('Fingerprint error: ', error);
-                throw error;
-            }
-        };
-        this.hardwareWalletManager =
-            sharedHardwareWalletManager || new hardware_wallet_manager_1.HardwareWalletManager();
-        // Set up event listeners
-        this.hardwareWalletManager.on('connected', ({ type }) => {
-            if (type === hardware_wallet_manager_1.HardwareWalletType.LEDGER) {
-                console.log('Ledger connected');
-            }
-        });
-        this.hardwareWalletManager.on('disconnected', ({ type }) => {
-            if (type === hardware_wallet_manager_1.HardwareWalletType.LEDGER) {
-                console.log('Ledger disconnected');
-                this.transport = null;
-                // Clear clients on disconnect
-                this.ledgerEVMClient = null;
-                this.ledgerUtxoClient = null;
-                this.walletHmacCache.clear();
-            }
-        });
-        this.hardwareWalletManager.on('connectionFailed', ({ type, error }) => {
-            if (type === hardware_wallet_manager_1.HardwareWalletType.LEDGER) {
-                console.error('Ledger connection failed:', error);
-            }
-        });
-        this.evm = {
-            getEvmAddressAndPubKey: this.getEvmAddressAndPubKey,
-            signEVMTransaction: this.signEVMTransaction,
-            signPersonalMessage: this.signPersonalMessage,
-            signTypedData: this.signTypedData,
+                const approved = {
+                    accountIndex: index,
+                    expectedAddress: expected,
+                    unsignedTxHex: transaction.unsignedSerialized.replace(/^0x/, ''),
+                };
+                const digest = transaction.unsignedHash;
+                return this.run(async (host, assertCurrent) => {
+                    const result = await host.evm.signTransaction(approved);
+                    assertCurrent();
+                    const signature = checkedSignature(result, digest, expected);
+                    if (signature.legacyChainId !== null &&
+                        signature.legacyChainId !== transaction.chainId)
+                        throw invalidSignature();
+                    return {
+                        r: signature.r.slice(2),
+                        s: signature.s.slice(2),
+                        v: signature.v.toString(16),
+                    };
+                });
+            },
+            signPersonalMessage: async (request) => {
+                const expected = approvedAddress(request.expectedAddress);
+                const messageHex = Buffer.from(hexBytes(request.message)).toString('hex');
+                const digest = (0, ethers_1.hashMessage)(hexBytes(messageHex));
+                const approved = {
+                    accountIndex: accountIndex(request.accountIndex),
+                    expectedAddress: expected,
+                    messageHex,
+                };
+                return this.run(async (host) => checkedSignature(await host.evm.signPersonalMessage(approved), digest, expected).serialized);
+            },
+            signTypedData: async (request) => {
+                const { version } = request;
+                if (version !== eth_sig_util_1.SignTypedDataVersion.V3 &&
+                    version !== eth_sig_util_1.SignTypedDataVersion.V4)
+                    throw invalidRequest();
+                const expected = approvedAddress(request.expectedAddress);
+                const index = accountIndex(request.accountIndex);
+                let data, digest;
+                try {
+                    data = copyTypedData(request.data);
+                    digest = `0x${eth_sig_util_1.TypedDataUtils.eip712Hash(data, version).toString('hex')}`;
+                }
+                catch {
+                    throw invalidRequest();
+                }
+                const approved = {
+                    accountIndex: index,
+                    expectedAddress: expected,
+                    data,
+                    version,
+                };
+                return this.run(async (host) => checkedSignature(await host.evm.signTypedData(approved), digest, expected).serialized);
+            },
         };
         this.utxo = {
-            getUtxoAddress: this.getUtxoAddress,
-            getXpub: this.getXpub,
+            getUtxoAddress: ({ coin, index, slip44 }) => this.run((host) => host.utxo.getAddress({ currency: coin, accountIndex: index, slip44 })),
+            getXpub: ({ coin, index, slip44 }) => this.run((host) => host.utxo.getXpub({
+                currency: coin,
+                accountIndex: index,
+                slip44,
+                // Import must remain available for paths the device classifies as
+                // unusual. Ask for its confirmation once, without retrying denial.
+                checkOnDevice: true,
+            })),
             verifyUtxoAddress: this.verifyUtxoAddress,
         };
     }
-    /**
-     * Ensure Ledger is connected with automatic retry
-     * Note: This is automatically called by all operations through executeWithRetry
-     * External callers don't need to call this directly
-     */
-    async ensureConnection() {
-        await this.hardwareWalletManager.ensureConnection(hardware_wallet_manager_1.HardwareWalletType.LEDGER);
-        this.transport = await this.hardwareWalletManager.getLedgerConnection();
-        // Create clients if transport is available
-        if (this.transport && (!this.ledgerEVMClient || !this.ledgerUtxoClient)) {
-            this.ledgerEVMClient = new hw_app_eth_1.default(this.transport);
-            this.ledgerUtxoClient = new bitcoin_client_1.default(this.transport);
-        }
-    }
-    sanitizeData(data) {
-        switch (Object.prototype.toString.call(data)) {
-            case '[object Object]': {
-                const entries = Object.keys(data).map((k) => [
-                    k,
-                    this.sanitizeData(data[k]),
-                ]);
-                return Object.fromEntries(entries);
-            }
-            case '[object Array]':
-                return data.map((v) => this.sanitizeData(v));
-            case '[object BigInt]':
-                return data.toString();
-            default:
-                return data;
-        }
-    }
-    // Build a stable cache key for a policy bound to the device and derivation path
-    buildWalletCacheKey(fingerprint, walletPolicy) {
-        // Wallet HMACs are bound to a specific wallet policy id.
-        // The id commits to: version, wallet name, descriptor template hash, and the merkle root of keys.
-        // Therefore, caching by (fingerprint + walletId) avoids collisions across different networks
-        // that may share the same derivation path (e.g., multiple slip44=1 testnets).
-        return `${fingerprint}|${walletPolicy.getId().toString('hex')}`;
+    requireHost() {
+        if (!this.host)
+            throw (0, host_types_1.ledgerHostError)('HARDWARE_SIGNER_UNAVAILABLE', 'Ledger requires an authorized device host');
+        return this.host;
     }
-    // Lazily register the wallet policy and cache HMAC in memory only
-    async getOrRegisterHmac(walletPolicy, fingerprint) {
-        const cacheKey = this.buildWalletCacheKey(fingerprint, walletPolicy);
-        const cached = this.walletHmacCache.get(cacheKey);
-        if (cached)
-            return cached;
-        // If registerWallet is unavailable (tests/mocks), fall back to null HMAC
-        const registerWallet = this.ledgerUtxoClient?.registerWallet;
-        if (typeof registerWallet !== 'function') {
-            return null;
-        }
+    async run(operation) {
+        const generation = this.generation;
+        const host = this.requireHost();
+        // A visible platform host owns discovery, permission and device selection.
+        if (!host.getStatus().connected)
+            await host.connect({ useGrantedDevices: true });
+        const assertCurrent = () => {
+            if (generation !== this.generation)
+                throw (0, host_types_1.ledgerCancelledError)();
+        };
+        assertCurrent();
         try {
-            // Register once (device approval). If user cancels, error will propagate via retryOperation
-            const result = await registerWallet.call(this.ledgerUtxoClient, walletPolicy);
-            const walletHMAC = Array.isArray(result) ? result[1] : null;
-            if (walletHMAC && Buffer.isBuffer(walletHMAC)) {
-                this.walletHmacCache.set(cacheKey, walletHMAC);
-                return walletHMAC;
-            }
-            return null;
+            const result = await operation(host, assertCurrent);
+            assertCurrent();
+            return result;
         }
-        catch (e) {
-            // On failure, proceed without HMAC (device may prompt)
-            return null;
+        catch (error) {
+            assertCurrent();
+            throw error;
         }
     }
-    setHdPath(coin, accountIndex, slip44) {
-        if ((0, derivation_paths_1.isEvmCoin)(coin, slip44)) {
-            // For EVM, the "accountIndex" parameter is actually used as the address index
-            // EVM typically uses account 0, and different addresses are at different address indices
-            this.hdPath = (0, derivation_paths_1.getAddressDerivationPath)(coin, slip44, 0, // account is always 0 for EVM
-            false, // not a change address
-            accountIndex // this is actually the address index for EVM
-            );
-        }
-        else {
-            // For UTXO, use account-level derivation path
-            this.hdPath = (0, derivation_paths_1.getAccountDerivationPath)(coin, slip44, accountIndex);
-        }
-    }
-    /**
-     * Convert PSBT to Ledger format with retry logic
-     */
-    async convertToLedgerFormat(psbt, accountXpub, accountId, currency, slip44) {
-        return this.executeWithRetry(async () => {
-            // Ensure Ledger is connected before attempting operations
-            // This is now handled by executeWithRetry
-            // Build a bitcoinjs-bip32 network from slip44/currency so zpub/vpub parse directly
-            const { networks, types } = (0, sysweb3_network_1.getNetworkConfig)(slip44, currency);
-            const isTestnet = slip44 === 1;
-            const pubTypes = isTestnet
-                ? types.zPubType.testnet
-                : types.zPubType.mainnet;
-            const baseNetwork = isTestnet ? networks.testnet : networks.mainnet;
-            const network = {
-                ...baseNetwork,
-                bip32: {
-                    public: parseInt(pubTypes.vpub || pubTypes.zpub, 16),
-                    private: parseInt(pubTypes.vprv || pubTypes.zprv, 16),
-                },
-            };
-            const bip32 = (0, bip32_1.default)(secp256k1_1.default);
-            const accountNode = bip32.fromBase58(accountXpub, network);
-            // Get master fingerprint
-            const fingerprint = await this.getMasterFingerprint();
-            // Enhance each input with bip32Derivation
-            const missingInputDerivations = [];
-            for (let i = 0; i < psbt.inputCount; i++) {
-                const dataInput = psbt.data.inputs[i];
-                // External inputs are already authorized by their final scripts. Do
-                // not invent wallet derivations or ask the device to sign them again.
-                if (dataInput.finalScriptSig || dataInput.finalScriptWitness)
-                    continue;
-                // Skip if already has bip32Derivation
-                if (dataInput.bip32Derivation && dataInput.bip32Derivation.length > 0) {
-                    continue;
-                }
-                // Ensure witnessUtxo is present if nonWitnessUtxo exists
-                if (!dataInput.witnessUtxo && dataInput.nonWitnessUtxo) {
-                    const txBuffer = dataInput.nonWitnessUtxo;
-                    const tx = syscoinjs_lib_1.Transaction.fromBuffer(txBuffer);
-                    const vout = psbt.txInputs[i].index;
-                    if (tx.outs[vout]) {
-                        dataInput.witnessUtxo = {
-                            script: tx.outs[vout].script,
-                            value: tx.outs[vout].value,
-                        };
-                    }
-                }
-                // Extract path from unknownKeyVals by searching for the key, not using hardcoded index
-                let pathFromInput = null;
-                if (dataInput.unknownKeyVals && dataInput.unknownKeyVals.length > 0) {
-                    for (const kv of dataInput.unknownKeyVals) {
-                        const keyStr = Buffer.from(kv.key).toString();
-                        if (keyStr === 'path') {
-                            pathFromInput = Buffer.from(kv.value).toString();
-                            break;
-                        }
-                    }
-                }
-                let bip32Derivation = null;
-                if (pathFromInput) {
-                    const fullPath = pathFromInput;
-                    const accountPath = (0, derivation_paths_1.getAccountDerivationPath)(currency, slip44, accountId);
-                    const relativePath = fullPath
-                        .replace(accountPath, '')
-                        .replace(/^\//, '');
-                    const derivationTokens = relativePath.split('/').filter((t) => t);
-                    const derivedAccount = derivationTokens.reduce((acc, token) => {
-                        const index = parseInt(token);
-                        if (isNaN(index)) {
-                            return acc;
-                        }
-                        return acc.derive(index);
-                    }, accountNode);
-                    const rawPubkey = derivedAccount.publicKey;
-                    const pubkeyBuf = Buffer.isBuffer(rawPubkey)
-                        ? rawPubkey
-                        : Buffer.from(rawPubkey);
-                    if (pubkeyBuf && pubkeyBuf.length === 33) {
-                        // Add the bip32Derivation that Ledger needs
-                        bip32Derivation = {
-                            masterFingerprint: Buffer.from(fingerprint, 'hex'),
-                            path: fullPath,
-                            pubkey: pubkeyBuf,
-                        };
-                        psbt.updateInput(i, {
-                            bip32Derivation: [bip32Derivation],
-                        });
-                    }
-                }
-                // Check the updated PSBT state (avoid stale local references)
-                const updatedInput = psbt.data.inputs[i];
-                if (!updatedInput.bip32Derivation ||
-                    updatedInput.bip32Derivation.length === 0) {
-                    missingInputDerivations.push(i);
-                }
-            }
-            // Enhance each output with bip32Derivation when it's a change/output owned by the wallet
-            for (let i = 0; i < psbt.data.outputs.length; i++) {
-                const dataOutput = psbt.data.outputs[i];
-                // Skip if derivation already present
-                if (dataOutput.bip32Derivation &&
-                    dataOutput.bip32Derivation.length > 0) {
-                    continue;
-                }
-                // Extract path from unknownKeyVals by searching for the key 'path'
-                let pathFromOutput = null;
-                if (dataOutput.unknownKeyVals && dataOutput.unknownKeyVals.length > 0) {
-                    for (const kv of dataOutput.unknownKeyVals) {
-                        const keyStr = Buffer.from(kv.key).toString();
-                        if (keyStr === 'path') {
-                            pathFromOutput = Buffer.from(kv.value).toString();
-                            break;
-                        }
-                    }
-                }
-                if (pathFromOutput) {
-                    let bip32Derivation = null;
-                    const fullPath = pathFromOutput;
-                    const accountPath = (0, derivation_paths_1.getAccountDerivationPath)(currency, slip44, accountId);
-                    const relativePath = fullPath
-                        .replace(accountPath, '')
-                        .replace(/^\//, '');
-                    const derivationTokens = relativePath.split('/').filter((t) => t);
-                    const derivedAccount = derivationTokens.reduce((acc, token) => {
-                        const index = parseInt(token);
-                        if (isNaN(index)) {
-                            return acc;
-                        }
-                        return acc.derive(index);
-                    }, accountNode);
-                    const rawOutPubkey = derivedAccount.publicKey;
-                    const outPubkeyBuf = Buffer.isBuffer(rawOutPubkey)
-                        ? rawOutPubkey
-                        : Buffer.from(rawOutPubkey);
-                    if (outPubkeyBuf && outPubkeyBuf.length === 33) {
-                        bip32Derivation = {
-                            masterFingerprint: Buffer.from(fingerprint, 'hex'),
-                            path: fullPath,
-                            pubkey: outPubkeyBuf,
-                        };
-                        psbt.updateOutput(i, {
-                            bip32Derivation: [bip32Derivation],
-                        });
-                    }
-                    // Outputs without valid derivation are allowed (external recipients)
-                }
-            }
-            // If any wallet-owned inputs/outputs are missing bip32Derivation, fail early with a clear error
-            if (missingInputDerivations.length > 0) {
-                const parts = [];
-                parts.push(`inputs [${missingInputDerivations.join(', ')}]`);
-                throw new Error(`convertToLedgerFormat: Missing bip32Derivation for ${parts.join(' and ')}. Ensure PSBT includes a 'path' unknownKeyVal or BIP32_DERIVATION for wallet-owned entries.`);
-            }
-            return psbt;
-        }, 'convertToLedgerFormat');
-    }
-    /**
-     * Execute operation with automatic retry
-     */
-    async executeWithRetry(operation, operationName) {
-        // Ensure connection first
-        await this.ensureConnection();
-        // Use hardware wallet manager's retry mechanism
-        return this.hardwareWalletManager.retryOperation(operation, operationName, {
-            maxRetries: 3,
-            baseDelay: 1000,
-            maxDelay: 5000,
-            backoffMultiplier: 2,
-        });
-    }
-    /**
-     * Get hardware wallet status
-     */
     getStatus() {
-        return this.hardwareWalletManager
-            .getStatus()
-            .find((s) => s.type === hardware_wallet_manager_1.HardwareWalletType.LEDGER);
+        const connected = this.host?.getStatus().connected === true;
+        return {
+            type: hardware_wallet_manager_1.HardwareWalletType.LEDGER,
+            connected,
+            status: connected
+                ? hardware_wallet_manager_1.ConnectionStatus.CONNECTED
+                : hardware_wallet_manager_1.ConnectionStatus.DISCONNECTED,
+        };
     }
-    /**
-     * Clean up resources
-     */
     async destroy() {
-        await this.hardwareWalletManager.destroy();
-        this.transport = null;
+        // Revoke pending responses synchronously, before platform teardown awaits.
+        this.generation++;
+        const cleanup = this.sharedHardwareWalletManager?.destroy();
+        const disconnect = this.host?.disconnect();
+        await Promise.all([cleanup, disconnect]);
     }
 }
 exports.LedgerKeyring = LedgerKeyring;