@swapkit/wallet-hardware 4.9.8 → 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

@@ -10,16 +10,15 @@ import {
   getRPCUrl,
   NetworkDerivationPath,
   SwapKitError,
-  THORConfig,
   type UTXOChain,
   WalletOption,
 } from "@swapkit/helpers";
-import type { ThorchainDepositParams } from "@swapkit/toolboxes/cosmos";
 import {
   addInputsAndOutputs,
   assertDerivationIndex,
   compileMemo,
   createHDWalletHelpers,
+  getNetworkForChain,
   getUTXOAccountIndexFromPath,
   getUTXOAccountPath,
   getUTXOAddressPath,
@@ -28,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";
 
 /**
@@ -39,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 });
 
@@ -80,11 +79,12 @@ export const ledgerWallet = createWallet({
     [Chain.Polygon]: true,
     [Chain.Ripple]: true,
     [Chain.Sui]: true,
+    [Chain.THORChain]: true,
     [Chain.Tron]: true,
     [Chain.XLayer]: true,
     // ZEC: still on bespoke signPCZT path
-    // THORChain: needs signAmino added to THORChainLedger (V3 plan PR)
   },
+  getExtendedPublicKey: getLedgerExtendedPublicKey,
   name: "connectLedger",
   supportedChains: [
     Chain.Arbitrum,
@@ -126,33 +126,30 @@ function reduceMemo(memo?: string, affiliateAddress = "t") {
   return removedAffiliate?.substring(0, removedAffiliate.lastIndexOf(":"));
 }
 
-function recursivelyOrderKeys(unordered: any) {
-  // If it's an array - recursively order any
-  // dictionary items within the array
-  if (Array.isArray(unordered)) {
-    unordered.forEach((item, index) => {
-      unordered[index] = recursivelyOrderKeys(item);
-    });
-    return unordered;
+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 });
   }
 
-  // If it's an object - let's order the keys
-  if (typeof unordered !== "object") return unordered;
-  const ordered: any = {};
-  const sortedKeys = Object.keys(unordered).sort();
+  const utxoChain = chain as UTXOChain;
+  const signer = await getLedgerClient({ chain: utxoChain, derivationPath });
+  if (!signer.getExtendedPublicKey) return undefined;
 
-  for (const key of sortedKeys) {
-    ordered[key] = recursivelyOrderKeys(unordered[key]);
-  }
-
-  return ordered;
-}
+  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);
 
-function stringifyKeysInOrder(data: any) {
-  return JSON.stringify(recursivelyOrderKeys(data));
+  return { accountIndex: getUTXOAccountIndexFromPath(accountPath), path, xpub };
 }
 
 async function getWalletMethods({
+  address: providedAddress,
   chain,
   derivationPath,
   transport,
@@ -169,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];
@@ -207,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);
 
@@ -221,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 };
       }
@@ -380,6 +388,7 @@ async function getWalletMethods({
         deriveAddresses,
         getExtendedPublicKey,
         getExtendedPublicKeyInfo,
+        signAndBroadcastTransaction,
         transfer,
         transferFromMultipleAddresses,
       };
@@ -444,85 +453,13 @@ async function getWalletMethods({
     }
 
     case Chain.THORChain: {
-      const { SignMode } = await import("cosmjs-types/cosmos/tx/signing/v1beta1/signing.js");
-      const { TxRaw } = await import("cosmjs-types/cosmos/tx/v1beta1/tx.js");
-      const importedSigning = await import("@cosmjs/proto-signing");
-      const encodePubkey = importedSigning.encodePubkey ?? importedSigning.default?.encodePubkey;
-      const makeAuthInfoBytes = importedSigning.makeAuthInfoBytes ?? importedSigning.default?.makeAuthInfoBytes;
-      const {
-        createStargateClient,
-        buildEncodedTxBody,
-        getCosmosToolbox,
-        buildAminoMsg,
-        getDefaultChainFee,
-        fromBase64,
-        parseAminoMessageForDirectSigning,
-      } = await import("@swapkit/toolboxes/cosmos");
-      const toolbox = getCosmosToolbox(chain);
       const signer = await getLedgerClient({ chain, derivationPath, transport });
+      const { getCosmosToolbox } = await import("@swapkit/toolboxes/cosmos");
+      const toolbox = getCosmosToolbox(chain, { signer });
       const address = await getLedgerAddress({ chain, ledgerClient: signer });
+      const { sign: signMessage } = signer;
 
-      const fee = getDefaultChainFee(chain);
-      const { pubkey: value, signTransaction, sign: signMessage } = signer;
-
-      // ANCHOR (@Chillios): Same parts in methods + can extract StargateClient init to toolbox
-      const thorchainTransfer = async ({
-        memo = "",
-        assetValue,
-        ...rest
-      }: GenericTransferParams | ThorchainDepositParams) => {
-        const account = await toolbox.getAccount(address);
-        if (!account) throw new SwapKitError("wallet_ledger_invalid_account");
-        if (!assetValue) throw new SwapKitError("wallet_ledger_invalid_asset");
-        if (!value) throw new SwapKitError("wallet_ledger_pubkey_not_found");
-
-        const { accountNumber, sequence: sequenceNumber } = account;
-        const sequence = (sequenceNumber || 0).toString();
-
-        const orderedMessages = recursivelyOrderKeys([buildAminoMsg({ assetValue, memo, sender: address, ...rest })]);
-
-        // get tx signing msg
-        const rawSendTx = stringifyKeysInOrder({
-          account_number: accountNumber?.toString(),
-          chain_id: THORConfig.chainId,
-          fee,
-          memo,
-          msgs: orderedMessages,
-          sequence,
-        });
-
-        const signatures = await signTransaction(rawSendTx, sequence);
-        if (!signatures) throw new SwapKitError("wallet_ledger_signing_error");
-
-        const pubkey = encodePubkey({ type: "tendermint/PubKeySecp256k1", value });
-        const msgs = orderedMessages.map(parseAminoMessageForDirectSigning);
-        const bodyBytes = await buildEncodedTxBody({ chain, memo, msgs });
-
-        const authInfoBytes = makeAuthInfoBytes(
-          [{ pubkey, sequence: Number(sequence) }],
-          fee.amount,
-          Number.parseInt(fee.gas, 10),
-          undefined,
-          undefined,
-          SignMode.SIGN_MODE_LEGACY_AMINO_JSON,
-        );
-
-        const signature = signatures?.[0]?.signature ? fromBase64(signatures[0].signature) : Uint8Array.from([]);
-
-        const txRaw = TxRaw.fromPartial({ authInfoBytes, bodyBytes, signatures: [signature] });
-        const txBytes = TxRaw.encode(txRaw).finish();
-        const rpcUrl = await getRPCUrl(Chain.THORChain);
-
-        const broadcaster = await createStargateClient(rpcUrl);
-        const { transactionHash } = await broadcaster.broadcastTx(txBytes);
-
-        return transactionHash;
-      };
-
-      const transfer = (params: GenericTransferParams) => thorchainTransfer(params);
-      const deposit = (params: ThorchainDepositParams) => thorchainTransfer(params);
-
-      return { ...toolbox, address, deposit, signMessage, transfer };
+      return { ...toolbox, address, signMessage };
     }
 
     case Chain.Near: {