@swapkit/wallet-hardware 4.9.9 → 4.9.10

package/src/ledger/clients/utxo-legacy-adapter.ts

@@ -1,5 +1,5 @@
 import { hex } from "@scure/base";
-import type { UTXOChain } from "@swapkit/helpers";
+import { SwapKitError, type UTXOChain } from "@swapkit/helpers";
 import type { UTXOType } from "@swapkit/toolboxes/utxo";
 import type { Transaction } from "@swapkit/utxo-signer";
 
@@ -7,15 +7,15 @@ import type { Transaction } from "@swapkit/utxo-signer";
  * Extract per-input metadata from a V3 PSBT in the shape the legacy
  * `@ledgerhq/hw-app-btc.createPaymentTransaction` adapter expects.
  *
- * For segwit inputs the SwapKit V3 API populates `witnessUtxo`; for legacy
- * (BCH/DOGE/DASH) it populates `nonWitnessUtxo` with the full prior-tx bytes.
- * We re-encode the parsed `nonWitnessUtxo` back to hex via `RawTx.encode` so
- * `btcApp.splitTransaction(hex)` can consume it.
+ * The legacy Ledger signer still needs the full previous tx hex for
+ * `btcApp.splitTransaction(hex)`. Some V3 PSBTs only include `witnessUtxo`,
+ * so we fetch the previous raw tx when `nonWitnessUtxo` is absent.
  *
  * Single-address account assumption: all inputs share our derivation path.
  */
-export async function extractInputsFromPsbt(tx: Transaction): Promise<UTXOType[]> {
+export async function extractInputsFromPsbt(tx: Transaction, chain: UTXOChain): Promise<UTXOType[]> {
   const { RawTx } = await import("@swapkit/utxo-signer");
+  const { getUtxoApi } = await import("@swapkit/toolboxes/utxo");
   const inputs: UTXOType[] = [];
 
   for (let i = 0; i < tx.inputsLength; i++) {
@@ -25,31 +25,53 @@ export async function extractInputsFromPsbt(tx: Transaction): Promise<UTXOType[]
       throw new Error(`PSBT input ${i} is missing txid/index`);
     }
 
-    const txHex = input.nonWitnessUtxo ? hex.encode(RawTx.encode(input.nonWitnessUtxo)) : "";
+    const txid = hex.encode(input.txid);
+    const txHex = input.nonWitnessUtxo
+      ? hex.encode(RawTx.encode(input.nonWitnessUtxo))
+      : await getUtxoApi(chain).getRawTx(txid);
+    if (!txHex) {
+      throw new SwapKitError("wallet_ledger_invalid_params", {
+        chain,
+        inputIndex: i,
+        reason: "Unable to resolve previous transaction hex for Ledger signing",
+        txid,
+      });
+    }
     const witnessUtxo = input.witnessUtxo
       ? { script: input.witnessUtxo.script, value: Number(input.witnessUtxo.amount) }
       : undefined;
+    const nonWitnessPrevout = input.index !== undefined ? input.nonWitnessUtxo?.outputs?.[input.index] : undefined;
+    const value = witnessUtxo?.value ?? (nonWitnessPrevout ? Number(nonWitnessPrevout.amount) : 0);
 
-    inputs.push({
-      hash: hex.encode(input.txid),
-      index: input.index,
-      txHex,
-      value: witnessUtxo?.value ?? 0,
-      witnessUtxo,
-    } as UTXOType);
+    inputs.push({ hash: txid, index: input.index, txHex, value, witnessUtxo } as UTXOType);
   }
 
   return inputs;
 }
 
+export async function signLegacyPsbtTransaction({
+  legacyClient,
+  chain,
+  tx,
+}: {
+  legacyClient: { signTransaction: (tx: Transaction, inputUtxos: UTXOType[]) => Promise<string> };
+  chain: UTXOChain;
+  tx: Transaction;
+}): Promise<string> {
+  const inputUtxos = await extractInputsFromPsbt(tx, chain);
+  return legacyClient.signTransaction(tx, inputUtxos);
+}
+
 /**
  * Build a toolbox-compatible signer from the existing legacy Ledger UTXO
- * client. The toolbox synthesizes `signAndBroadcastTransaction` on top of
- * `signer.signTransaction(tx) → Transaction`.
+ * client. Callers that need sign-and-broadcast should broadcast the raw hex
+ * from `signLegacyPsbtTransaction` directly; the legacy Ledger app returns an
+ * already-finalized transaction that should not be passed back to toolbox
+ * finalization.
  */
 export function createLegacyPsbtSigner({
   legacyClient,
-  chain: _chain,
+  chain,
   address,
 }: {
   legacyClient: { signTransaction: (tx: Transaction, inputUtxos: UTXOType[]) => Promise<string> };
@@ -59,8 +81,7 @@ export function createLegacyPsbtSigner({
   return {
     getAddress: async () => address,
     signTransaction: async (tx: Transaction): Promise<Transaction> => {
-      const inputUtxos = await extractInputsFromPsbt(tx);
-      const signedTxHex = await legacyClient.signTransaction(tx, inputUtxos);
+      const signedTxHex = await signLegacyPsbtTransaction({ chain, legacyClient, tx });
 
       const { Transaction: TxClass } = await import("@swapkit/utxo-signer");
       // `Transaction.fromRaw` parses a serialised tx (no PSBT envelope) — exactly

package/src/ledger/index.ts

@@ -18,6 +18,7 @@ import {
   assertDerivationIndex,
   compileMemo,
   createHDWalletHelpers,
+  getNetworkForChain,
   getUTXOAccountIndexFromPath,
   getUTXOAccountPath,
   getUTXOAddressPath,
@@ -26,7 +27,7 @@ import {
   type UTXOForMultiAddressTransfer,
 } from "@swapkit/toolboxes/utxo";
 import type { Transaction } from "@swapkit/utxo-signer";
-import { createWallet, getWalletSupportedChains } from "@swapkit/wallet-core";
+import { createWallet, getWalletSupportedChains, type HardwareExtendedPublicKeyInfo } from "@swapkit/wallet-core";
 import { getLedgerAddress, getLedgerClient } from "./helpers";
 
 /**
@@ -37,21 +38,21 @@ import { getLedgerAddress, getLedgerClient } from "./helpers";
  * client and will NOT recreate it on `forceReconnect`. When omitted, the
  * default browser flow (WebHID / WebUSB via `navigator.usb`) is used.
  */
-export type ConnectLedgerOptions = { transport?: Transport };
+export type ConnectLedgerOptions = { address?: string; transport?: Transport };
 
 export const ledgerWallet = createWallet({
   connect: ({ addChain, supportedChains, walletType }) =>
     async function connectLedger(
       chains: Chain[],
       derivationPath?: DerivationPathArray,
-      { transport }: ConnectLedgerOptions = {},
+      { address, transport }: ConnectLedgerOptions = {},
     ) {
       const [chain] = filterSupportedChains({ chains, supportedChains, walletType });
 
       if (!chain) return false;
 
       const resolvedPath = derivationPath ?? (NetworkDerivationPath[chain] as DerivationPathArray | undefined);
-      const walletMethods = await getWalletMethods({ chain, derivationPath: resolvedPath, transport });
+      const walletMethods = await getWalletMethods({ address, chain, derivationPath: resolvedPath, transport });
 
       addChain({ ...walletMethods, chain, walletType: WalletOption.LEDGER });
 
@@ -83,6 +84,7 @@ export const ledgerWallet = createWallet({
     [Chain.XLayer]: true,
     // ZEC: still on bespoke signPCZT path
   },
+  getExtendedPublicKey: getLedgerExtendedPublicKey,
   name: "connectLedger",
   supportedChains: [
     Chain.Arbitrum,
@@ -124,7 +126,30 @@ function reduceMemo(memo?: string, affiliateAddress = "t") {
   return removedAffiliate?.substring(0, removedAffiliate.lastIndexOf(":"));
 }
 
+export async function getLedgerExtendedPublicKey(
+  chain: Chain,
+  derivationPath?: DerivationPathArray,
+  { accountIndex }: { accountIndex?: number } = {},
+): Promise<HardwareExtendedPublicKeyInfo | undefined> {
+  if (![Chain.BitcoinCash, Chain.Bitcoin, Chain.Dash, Chain.Dogecoin, Chain.Litecoin, Chain.Zcash].includes(chain)) {
+    throw new SwapKitError("wallet_chain_not_supported", { chain, wallet: WalletOption.LEDGER });
+  }
+
+  const utxoChain = chain as UTXOChain;
+  const signer = await getLedgerClient({ chain: utxoChain, derivationPath });
+  if (!signer.getExtendedPublicKey) return undefined;
+
+  const accountPath = getUTXOAccountPath({ accountIndex, chain: utxoChain, derivationPath });
+  const path = derivationPathToString(accountPath);
+  const ledgerPath = chain === Chain.Bitcoin || chain === Chain.Litecoin ? path : path.replace(/^m\//, "");
+  const xpubVersion = getNetworkForChain(utxoChain).bip32.public;
+  const xpub = await signer.getExtendedPublicKey(ledgerPath, xpubVersion);
+
+  return { accountIndex: getUTXOAccountIndexFromPath(accountPath), path, xpub };
+}
+
 async function getWalletMethods({
+  address: providedAddress,
   chain,
   derivationPath,
   transport,
@@ -141,31 +166,41 @@ async function getWalletMethods({
 
       const signer = await getLedgerClient({ chain, derivationPath, transport });
 
-      const address = await getLedgerAddress({ chain, ledgerClient: signer });
+      const address = providedAddress ?? (await getLedgerAddress({ chain, ledgerClient: signer }));
 
       // V3 toolbox signer:
-      //  - BTC/LTC use the modern `ledger-bitcoin` AppClient with native PSBT signing.
-      //  - BCH/DOGE/DASH use the legacy `hw-app-btc` adapter that pulls
+      //  - BTC uses the modern `ledger-bitcoin` AppClient with native PSBT signing.
+      //  - LTC/BCH/DOGE/DASH use the legacy `hw-app-btc` adapter that pulls
       //    `nonWitnessUtxo` (full prev-tx hex) out of the API PSBT.
+      //    The Litecoin Ledger app does not support the `ledger-bitcoin`
+      //    policy APDUs and returns CLA_NOT_SUPPORTED.
       //  - ZEC stays on the bespoke `signPCZT` flow for now.
       let toolboxSigner:
         | { getAddress: () => Promise<string>; signTransaction: (tx: Transaction) => Promise<Transaction> }
         | undefined;
-      if (chain === Chain.Bitcoin || chain === Chain.Litecoin) {
-        const { BitcoinPsbtLedger, LitecoinPsbtLedger } = await import("./clients/utxo-psbt");
-        const psbtClient =
-          chain === Chain.Bitcoin
-            ? BitcoinPsbtLedger(derivationPath, transport)
-            : LitecoinPsbtLedger(derivationPath, transport);
+      let signAndBroadcastLegacyPsbtTransaction: ((tx: Transaction) => Promise<string>) | undefined;
+      if (chain === Chain.Bitcoin) {
+        const { BitcoinPsbtLedger } = await import("./clients/utxo-psbt");
+        const psbtClient = BitcoinPsbtLedger(derivationPath, transport);
         toolboxSigner = { getAddress: psbtClient.getAddress, signTransaction: psbtClient.signTransaction };
-      } else if (chain === Chain.BitcoinCash || chain === Chain.Dogecoin || chain === Chain.Dash) {
-        const { createLegacyPsbtSigner } = await import("./clients/utxo-legacy-adapter");
+      } else if (
+        chain === Chain.BitcoinCash ||
+        chain === Chain.Dogecoin ||
+        chain === Chain.Dash ||
+        chain === Chain.Litecoin
+      ) {
+        const { createLegacyPsbtSigner, signLegacyPsbtTransaction } = await import("./clients/utxo-legacy-adapter");
         toolboxSigner = createLegacyPsbtSigner({ address, chain: utxoChain, legacyClient: signer });
+        signAndBroadcastLegacyPsbtTransaction = async (tx) => {
+          const signedTxHex = await signLegacyPsbtTransaction({ chain: utxoChain, legacyClient: signer, tx });
+          return toolbox.broadcastTx(signedTxHex);
+        };
       }
 
       const toolbox = toolboxSigner
         ? await getUtxoToolbox(utxoChain, { signer: toolboxSigner })
         : getUtxoToolbox(utxoChain);
+      const signAndBroadcastTransaction = signAndBroadcastLegacyPsbtTransaction ?? toolbox.signAndBroadcastTransaction;
 
       const transfer = async (params: UTXOBuildTxParams) => {
         const feeRate = params.feeRate || (await toolbox.getFeeRates())[FeeOption.Average];
@@ -179,8 +214,8 @@ async function getWalletMethods({
           sender: address,
         });
 
-        // Cast tx to Transaction - signTransaction handles both Transaction and ZcashTransaction
-        // via tx.unsignedTx which exists on both types
+        // Legacy Ledger UTXO signing returns finalized raw tx hex, so transfer
+        // broadcasts directly instead of routing through toolbox finalization.
         const txHex = await signer.signTransaction(tx as Transaction, inputs);
         const txHash = await toolbox.broadcastTx(txHex);
 
@@ -193,7 +228,8 @@ async function getWalletMethods({
         const accountPath = getUTXOAccountPath({ accountIndex, chain: utxoChain, derivationPath });
         const path = derivationPathToString(accountPath);
         const ledgerPath = chain === Chain.Bitcoin || chain === Chain.Litecoin ? path : path.replace(/^m\//, "");
-        const xpub = await signer.getExtendedPublicKey(ledgerPath);
+        const xpubVersion = getNetworkForChain(utxoChain).bip32.public;
+        const xpub = await signer.getExtendedPublicKey(ledgerPath, xpubVersion);
 
         return { accountIndex: getUTXOAccountIndexFromPath(accountPath), path, xpub };
       }
@@ -352,6 +388,7 @@ async function getWalletMethods({
         deriveAddresses,
         getExtendedPublicKey,
         getExtendedPublicKeyInfo,
+        signAndBroadcastTransaction,
         transfer,
         transferFromMultipleAddresses,
       };