@swapkit/wallet-hardware 4.9.9 → 4.9.11

package/src/trezor/index.ts

@@ -1,4 +1,4 @@
-import { HDKey } from "@scure/bip32";
+import { HDKey, type Versions } from "@scure/bip32";
 import {
   Chain,
   type DerivationPathArray,
@@ -6,6 +6,7 @@ import {
   FeeOption,
   filterSupportedChains,
   type GenericTransferParams,
+  NetworkDerivationPath,
   SKConfig,
   SwapKitError,
   type UTXOChain,
@@ -14,7 +15,6 @@ import {
 import {
   assertDerivationIndex,
   createHDWalletHelpers,
-  deriveAddressesFromXpub,
   getNetworkForChain,
   getUTXOAccountIndexFromPath,
   getUTXOAccountPath,
@@ -23,12 +23,13 @@ import {
   type UTXOType,
 } from "@swapkit/toolboxes/utxo";
 import type { BTCNetwork, PCZT, Transaction, ZcashTransaction } from "@swapkit/utxo-signer";
-import { NETWORKS, ZcashConsensusBranchId, ZcashVersionGroupId } from "@swapkit/utxo-signer";
-import { createWallet, getWalletSupportedChains } from "@swapkit/wallet-core";
+import { BCHSigHash, NETWORKS, ZcashConsensusBranchId, ZcashVersionGroupId } from "@swapkit/utxo-signer";
+import { createWallet, getWalletSupportedChains, type HardwareExtendedPublicKeyInfo } from "@swapkit/wallet-core";
 
 type TrezorBip32Derivation = [Uint8Array, { fingerprint: number; path: number[] }];
 type TrezorCoreMode = "auto" | "iframe" | "popup" | "suite-desktop" | "suite-web";
 type TrezorTransport = "BridgeTransport" | "WebUsbTransport" | "NodeUsbTransport";
+type ConnectTrezorOptions = { address?: string };
 type TrezorExtendedPublicKeyInfo = {
   accountIndex: number;
   chainCode?: string;
@@ -44,8 +45,16 @@ const TREZOR_CORE_MODES = new Set<TrezorCoreMode>(["auto", "iframe", "popup", "s
 const TREZOR_TRANSPORTS = new Set<TrezorTransport>(["BridgeTransport", "WebUsbTransport", "NodeUsbTransport"]);
 const DEFAULT_TREZOR_MANIFEST = { appName: "SwapKit", appUrl: "https://swapkit.dev", email: "support@swapkit.dev" };
 const DEFAULT_TREZOR_TRANSPORTS = ["WebUsbTransport" as const];
+const TREZOR_KEEP_SESSION_PARAMS = { keepSession: true } as const;
 const trezorXpubCache = new Map<string, TrezorExtendedPublicKeyInfo>();
 let trezorSessionDispose: Promise<void> | undefined;
+const EXTENDED_KEY_VERSION_CANDIDATES = [
+  NETWORKS.bitcoin.bip32,
+  NETWORKS.bitcoinCash.bip32,
+  NETWORKS.dash.bip32,
+  NETWORKS.dogecoin.bip32,
+  NETWORKS.litecoin.bip32,
+];
 
 async function disconnectTrezorSession() {
   trezorXpubCache.clear();
@@ -94,6 +103,98 @@ function getDefaultTrezorAppUrl() {
     : DEFAULT_TREZOR_MANIFEST.appUrl;
 }
 
+async function initTrezorConnect() {
+  const TrezorConnect = (await import("@trezor/connect-web")).default;
+
+  const trezorConfig = SKConfig.get("integrations").trezor as Record<string, unknown> | undefined;
+  const {
+    connectSrc,
+    coreMode,
+    debug,
+    interactionTimeout,
+    lazyLoad,
+    pendingTransportEvent,
+    popup,
+    transportReconnect,
+    transports,
+    ...manifestConfig
+  } = trezorConfig ?? {};
+  const manifest = {
+    ...manifestConfig,
+    appName: getTrezorManifestValue(trezorConfig?.appName, DEFAULT_TREZOR_MANIFEST.appName),
+    appUrl: getTrezorManifestValue(trezorConfig?.appUrl, getDefaultTrezorAppUrl()),
+    email: getTrezorManifestValue(trezorConfig?.email, DEFAULT_TREZOR_MANIFEST.email),
+  };
+  const isLocalhost =
+    typeof globalThis.location !== "undefined" && ["localhost", "127.0.0.1"].includes(globalThis.location.hostname);
+  const resolvedCoreMode = normalizeTrezorCoreMode(coreMode) ?? "popup";
+  const resolvedTransports = normalizeTrezorTransports(transports) ?? DEFAULT_TREZOR_TRANSPORTS;
+
+  if (trezorSessionDispose) {
+    await trezorSessionDispose;
+  }
+
+  if (isLocalhost) {
+    await TrezorConnect.dispose();
+  }
+
+  await TrezorConnect.init({
+    connectSrc: connectSrc as string | undefined,
+    coreMode: resolvedCoreMode,
+    debug: debug as boolean | undefined,
+    interactionTimeout: interactionTimeout as number | undefined,
+    lazyLoad: (lazyLoad as boolean | undefined) ?? false,
+    manifest,
+    pendingTransportEvent: pendingTransportEvent as boolean | undefined,
+    popup: (popup as boolean | undefined) ?? true,
+    transportReconnect: transportReconnect as boolean | undefined,
+    transports: resolvedTransports,
+  });
+
+  return { coreMode: resolvedCoreMode, isLocalhost, popup: (popup as boolean | undefined) ?? true, TrezorConnect };
+}
+
+export function normalizeTrezorExtendedPublicKey(xpub: string, chain: UTXOChain) {
+  const targetVersions = getNetworkForChain(chain).bip32;
+  const candidates = [
+    targetVersions,
+    ...EXTENDED_KEY_VERSION_CANDIDATES.filter(
+      (versions) => versions.public !== targetVersions.public || versions.private !== targetVersions.private,
+    ),
+  ];
+  let lastError: unknown;
+
+  for (const versions of candidates) {
+    try {
+      const key = HDKey.fromExtendedKey(xpub, versions as Versions);
+      if (!(key.publicKey && key.chainCode)) throw new Error("Extended key is missing public key data");
+
+      return new HDKey({
+        chainCode: key.chainCode,
+        depth: key.depth,
+        index: key.index,
+        parentFingerprint: key.parentFingerprint,
+        publicKey: key.publicKey,
+        versions: targetVersions,
+      }).publicExtendedKey;
+    } catch (error) {
+      lastError = error;
+    }
+  }
+
+  throw lastError instanceof Error ? lastError : new Error("Unable to parse Trezor extended public key");
+}
+
+function tryNormalizeTrezorExtendedPublicKey(xpub: string | undefined, chain: UTXOChain) {
+  if (!xpub) return undefined;
+
+  try {
+    return normalizeTrezorExtendedPublicKey(xpub, chain);
+  } catch {
+    return xpub;
+  }
+}
+
 function decodeOpReturnData(script: Uint8Array): string | null {
   if (script.length < 2 || script[0] !== 0x6a) return null;
   const dataLen = script[1];
@@ -151,12 +252,12 @@ function getPrevoutAmount(input: {
   return undefined;
 }
 
-function normalizeTrezorSignature(signatureHex: string) {
+export function normalizeTrezorSignature(signatureHex: string, chain: Chain) {
   const signature = Buffer.from(signatureHex, "hex");
   const derLength = signature[1] !== undefined ? signature[1] + 2 : undefined;
 
   if (derLength !== undefined && signature.length === derLength) {
-    return new Uint8Array([...signature, 0x01]);
+    return new Uint8Array([...signature, chain === Chain.BitcoinCash ? BCHSigHash.ALL : 0x01]);
   }
 
   return new Uint8Array(signature);
@@ -356,10 +457,20 @@ function buildUtxoOutputsForTrezor(
   return outputs;
 }
 
+function shouldUseTrezorPsbtSigner(chain: Chain) {
+  return chain === Chain.Bitcoin || chain === Chain.Litecoin;
+}
+
+function shouldUseTrezorSerializedSigner(chain: Chain) {
+  return chain === Chain.BitcoinCash || chain === Chain.Dash || chain === Chain.Dogecoin;
+}
+
 async function getTrezorWallet<T extends Chain>({
+  address: providedAddress,
   chain,
   derivationPath,
 }: {
+  address?: string;
   chain: T;
   derivationPath: DerivationPathArray;
 }) {
@@ -573,13 +684,16 @@ async function getTrezorWallet<T extends Chain>({
         throw new SwapKitError({ errorKey: "wallet_trezor_derivation_path_not_supported", info: { derivationPath } });
       }
 
+      const resolvedScriptType = scriptType;
       const coin = chain.toLowerCase();
 
       const getAddress = async (path: DerivationPathArray = derivationPath) => {
         const TrezorConnect = (await import("@trezor/connect-web")).default;
+        const pathString = derivationPathToString(path);
         const { success, payload } = await TrezorConnect.getAddress({
           coin,
-          path: derivationPathToString(path),
+          ...TREZOR_KEEP_SESSION_PARAMS,
+          path: pathString,
           showOnTrezor: false,
         });
 
@@ -597,46 +711,7 @@ async function getTrezorWallet<T extends Chain>({
         return payload.address;
       };
 
-      async function getAddressFromExtendedPublicKey() {
-        const accountInfo = await getExtendedPublicKeyInfo();
-        const addressIndex = Number(derivationPath[4] ?? 0);
-        const change = Boolean(derivationPath[3] ?? 0);
-
-        try {
-          // deriveAddressesFromXpub returns both external and change branches for each index.
-          const derivedAddress = deriveAddressesFromXpub({
-            accountIndex: accountInfo.accountIndex,
-            chain: utxoChain,
-            count: 1,
-            startIndex: addressIndex,
-            xpub: accountInfo.xpub,
-          }).find((derived) => derived.change === change && derived.index === addressIndex);
-
-          if (!derivedAddress) {
-            throw new SwapKitError({
-              errorKey: "wallet_trezor_failed_to_get_address",
-              info: { chain, error: "Unable to derive address from Trezor account public key" },
-            });
-          }
-
-          return derivedAddress.address;
-        } catch (error) {
-          if (error instanceof SwapKitError) throw error;
-
-          throw new SwapKitError({
-            errorKey: "wallet_trezor_failed_to_get_address",
-            info: {
-              chain,
-              error: error instanceof Error ? error.message : "Unable to derive address from Trezor xpub",
-            },
-          });
-        }
-      }
-
-      const address =
-        chain === Chain.Bitcoin || chain === Chain.Litecoin
-          ? await getAddressFromExtendedPublicKey()
-          : await getAddress();
+      const address = providedAddress ?? (await getAddress());
       const baseToolbox = getUtxoToolbox(chain);
 
       const signTransaction = async (tx: Transaction, inputs: UTXOType[], memo = "") => {
@@ -651,7 +726,7 @@ async function getTrezorWallet<T extends Chain>({
           address,
           memo,
           chain,
-          scriptType,
+          resolvedScriptType,
           toCashAddress,
           stripPrefix,
         );
@@ -661,7 +736,7 @@ async function getTrezorWallet<T extends Chain>({
           amount: value,
           prev_hash: hash,
           prev_index: index,
-          script_type: scriptType.input,
+          script_type: resolvedScriptType.input,
         }));
 
         const result = await TrezorConnect.signTransaction({ coin, inputs: trezorInputs, outputs });
@@ -687,7 +762,7 @@ async function getTrezorWallet<T extends Chain>({
         async function getFallbackDerivation(): Promise<TrezorBip32Derivation> {
           if (!fallbackPublicKey) {
             const accountInfo = await getExtendedPublicKeyInfo();
-            const accountKey = HDKey.fromExtendedKey(accountInfo.xpub);
+            const accountKey = HDKey.fromExtendedKey(accountInfo.xpub, network.bip32);
             const leaf = accountKey.derive(`m/${Number(derivationPath[3] ?? 0)}/${Number(derivationPath[4] ?? 0)}`);
 
             if (!leaf.publicKey) {
@@ -730,7 +805,7 @@ async function getTrezorWallet<T extends Chain>({
             amount,
             prev_hash: hexEncode.encode(input.txid),
             prev_index: input.index,
-            script_type: scriptType.input,
+            script_type: resolvedScriptType.input,
             ...(input.sequence !== undefined ? { sequence: input.sequence } : {}),
           });
         }
@@ -742,13 +817,14 @@ async function getTrezorWallet<T extends Chain>({
           address,
           "",
           chain,
-          scriptType,
+          resolvedScriptType,
           toCashAddress,
           stripPrefix,
         );
 
         const result = await TrezorConnect.signTransaction({
           coin,
+          ...TREZOR_KEEP_SESSION_PARAMS,
           inputs: trezorInputs,
           locktime: tx.lockTime,
           outputs,
@@ -767,12 +843,71 @@ async function getTrezorWallet<T extends Chain>({
           const pubkey = signerPubkeys[inputIndex];
           if (!(signatureHex && pubkey)) return;
 
-          tx.updateInput(inputIndex, { partialSig: [[pubkey, normalizeTrezorSignature(signatureHex)]] });
+          tx.updateInput(inputIndex, { partialSig: [[pubkey, normalizeTrezorSignature(signatureHex, chain)]] });
         });
 
         return tx;
       };
 
+      const signSerializedTransaction = async (tx: Transaction) => {
+        const TrezorConnect = (await import("@trezor/connect-web")).default;
+        const { hex: hexEncode } = await import("@scure/base");
+        const address_n = hardenDerivationPath(derivationPath);
+        const network = getNetworkForChain(chain as UTXOChain);
+
+        const trezorInputs = [];
+        for (let inputIndex = 0; inputIndex < tx.inputsLength; inputIndex++) {
+          const input = tx.getInput(inputIndex);
+          const amount = getPrevoutAmount(input);
+
+          if (!input.txid || input.index === undefined || !amount) {
+            throw new SwapKitError({
+              errorKey: "wallet_trezor_failed_to_sign_transaction",
+              info: { chain, error: `Input ${inputIndex} is missing prevout data required by Trezor` },
+            });
+          }
+
+          trezorInputs.push({
+            address_n,
+            amount,
+            prev_hash: hexEncode.encode(input.txid),
+            prev_index: input.index,
+            script_type: resolvedScriptType.input,
+            ...(input.sequence !== undefined ? { sequence: input.sequence } : {}),
+          });
+        }
+
+        const outputs = buildUtxoOutputsForTrezor(
+          tx,
+          network,
+          address_n,
+          address,
+          "",
+          chain,
+          resolvedScriptType,
+          toCashAddress,
+          stripPrefix,
+        );
+
+        const result = await TrezorConnect.signTransaction({
+          coin,
+          inputs: trezorInputs,
+          locktime: tx.lockTime,
+          outputs,
+          version: tx.version,
+        });
+
+        if (result.success) {
+          return result.payload.serializedTx;
+        }
+
+        const payload = result.payload as { error?: string; code?: string };
+        throw new SwapKitError({
+          errorKey: "wallet_trezor_failed_to_sign_transaction",
+          info: { chain, code: payload?.code ?? "unknown", error: payload?.error ?? "unknown", payload },
+        });
+      };
+
       const signTransactionWithMultipleInputs = async (
         tx: Transaction,
         inputs: Array<{ hash: string; index: number; value: number; derivationIndex: number; isChange: boolean }>,
@@ -789,7 +924,7 @@ async function getTrezorWallet<T extends Chain>({
           address,
           memo,
           chain,
-          scriptType,
+          resolvedScriptType,
           toCashAddress,
           stripPrefix,
         );
@@ -802,7 +937,7 @@ async function getTrezorWallet<T extends Chain>({
             amount: value,
             prev_hash: hash,
             prev_index: inputIndex,
-            script_type: scriptType.input,
+            script_type: resolvedScriptType.input,
           };
         });
 
@@ -897,12 +1032,15 @@ async function getTrezorWallet<T extends Chain>({
         return txHash;
       };
 
-      const toolbox =
-        chain === Chain.Bitcoin || chain === Chain.Litecoin
-          ? await getUtxoToolbox(utxoChain, {
-              signer: { getAddress: async () => address, signTransaction: signPsbtTransaction },
-            })
-          : baseToolbox;
+      const toolbox = shouldUseTrezorPsbtSigner(chain)
+        ? await getUtxoToolbox(utxoChain, {
+            signer: { getAddress: async () => address, signTransaction: signPsbtTransaction },
+          })
+        : baseToolbox;
+
+      const signAndBroadcastTransaction = shouldUseTrezorSerializedSigner(chain)
+        ? async (tx: Transaction) => baseToolbox.broadcastTx(await signSerializedTransaction(tx))
+        : toolbox.signAndBroadcastTransaction;
 
       async function getExtendedPublicKeyInfo({ accountIndex }: { accountIndex?: number } = {}) {
         const TrezorConnect = (await import("@trezor/connect-web")).default;
@@ -912,7 +1050,8 @@ async function getTrezorWallet<T extends Chain>({
         const cached = trezorXpubCache.get(cacheKey);
         if (cached) return cached;
 
-        const { success, payload } = await TrezorConnect.getPublicKey({ coin, path });
+        const result = await TrezorConnect.getPublicKey({ coin, path });
+        const { success, payload } = result;
 
         if (!success) {
           throw new SwapKitError({
@@ -921,6 +1060,8 @@ async function getTrezorWallet<T extends Chain>({
           });
         }
 
+        const xpub = normalizeTrezorExtendedPublicKey(payload.xpub, utxoChain);
+        const xpubSegwit = tryNormalizeTrezorExtendedPublicKey(payload.xpubSegwit, utxoChain);
         const info = {
           accountIndex: getUTXOAccountIndexFromPath(resolvedAccountPath),
           chainCode: payload.chainCode,
@@ -928,8 +1069,8 @@ async function getTrezorWallet<T extends Chain>({
           fingerprint: payload.fingerprint,
           path: payload.serializedPath,
           publicKey: payload.publicKey,
-          xpub: payload.xpub,
-          xpubSegwit: payload.xpubSegwit,
+          xpub,
+          xpubSegwit,
         };
 
         trezorXpubCache.set(cacheKey, info);
@@ -955,7 +1096,12 @@ async function getTrezorWallet<T extends Chain>({
         const resolvedAccountPath = getUTXOAccountPath({ accountIndex, chain: utxoChain, derivationPath });
         const fullPath = `${derivationPathToString(resolvedAccountPath)}/${Number(change)}/${index}`;
 
-        const { success, payload } = await TrezorConnect.getAddress({ coin, path: fullPath, showOnTrezor: false });
+        const { success, payload } = await TrezorConnect.getAddress({
+          coin,
+          ...TREZOR_KEEP_SESSION_PARAMS,
+          path: fullPath,
+          showOnTrezor: false,
+        });
 
         if (!success) {
           return undefined;
@@ -967,7 +1113,13 @@ async function getTrezorWallet<T extends Chain>({
           finalAddress = bchToolbox.stripPrefix(payload.address);
         }
 
-        const pubKeyResult = await TrezorConnect.getPublicKey({ coin, path: fullPath });
+        const pubKeyResult = await TrezorConnect.getPublicKey({
+          coin,
+          ...TREZOR_KEEP_SESSION_PARAMS,
+          path: fullPath,
+          scriptType: resolvedScriptType.input,
+          showOnTrezor: false,
+        });
         const pubkey = pubKeyResult.success ? pubKeyResult.payload.publicKey : "";
 
         return {
@@ -1004,7 +1156,7 @@ async function getTrezorWallet<T extends Chain>({
           showOnTrezor: false,
         }));
 
-        const { success, payload } = await TrezorConnect.getAddress({ bundle: paths });
+        const { success, payload } = await TrezorConnect.getAddress({ ...TREZOR_KEEP_SESSION_PARAMS, bundle: paths });
 
         if (!success || !Array.isArray(payload)) {
           return [];
@@ -1047,6 +1199,7 @@ async function getTrezorWallet<T extends Chain>({
         deriveAddresses: deriveAddressesBatch,
         getExtendedPublicKey,
         getExtendedPublicKeyInfo,
+        signAndBroadcastTransaction,
         signTransaction,
         signTransactionWithMultipleInputs,
         transfer,
@@ -1059,9 +1212,61 @@ async function getTrezorWallet<T extends Chain>({
   }
 }
 
+export async function getTrezorExtendedPublicKey(
+  chain: Chain,
+  derivationPath?: DerivationPathArray,
+  { accountIndex }: { accountIndex?: number } = {},
+): Promise<HardwareExtendedPublicKeyInfo | undefined> {
+  if (![Chain.BitcoinCash, Chain.Bitcoin, Chain.Dash, Chain.Dogecoin, Chain.Litecoin].includes(chain)) {
+    throw new SwapKitError({ errorKey: "wallet_chain_not_supported", info: { chain, wallet: WalletOption.TREZOR } });
+  }
+
+  const { TrezorConnect } = await initTrezorConnect();
+  const utxoChain = chain as UTXOChain;
+  const resolvedDerivationPath = derivationPath ?? (NetworkDerivationPath[chain] as DerivationPathArray);
+  const coin = chain.toLowerCase();
+
+  const resolvedAccountPath = getUTXOAccountPath({
+    accountIndex,
+    chain: utxoChain,
+    derivationPath: resolvedDerivationPath,
+  });
+  const path = derivationPathToString(resolvedAccountPath);
+  const cacheKey = `${chain}:${path}`;
+  const cached = trezorXpubCache.get(cacheKey);
+  if (cached) return cached;
+
+  const { success, payload } = await TrezorConnect.getPublicKey({ coin, path, showOnTrezor: true });
+
+  if (!success) {
+    throw new SwapKitError({
+      errorKey: "wallet_trezor_failed_to_get_public_key",
+      info: { chain, error: (payload as { error: string; code?: string }).error || "Unknown error" },
+    });
+  }
+
+  const info = {
+    accountIndex: getUTXOAccountIndexFromPath(resolvedAccountPath),
+    chainCode: payload.chainCode,
+    depth: payload.depth,
+    fingerprint: payload.fingerprint,
+    path: payload.serializedPath,
+    publicKey: payload.publicKey,
+    xpub: normalizeTrezorExtendedPublicKey(payload.xpub, utxoChain),
+    xpubSegwit: tryNormalizeTrezorExtendedPublicKey(payload.xpubSegwit, utxoChain),
+  };
+
+  trezorXpubCache.set(cacheKey, info);
+  return info;
+}
+
 export const trezorWallet = createWallet({
   connect: ({ addChain, supportedChains, walletType }) =>
-    async function connectTrezor(chains: Chain[], derivationPath: DerivationPathArray) {
+    async function connectTrezor(
+      chains: Chain[],
+      derivationPath: DerivationPathArray,
+      { address }: ConnectTrezorOptions = {},
+    ) {
       const [chain] = filterSupportedChains({ chains, supportedChains, walletType });
       if (!chain) {
         throw new SwapKitError({
@@ -1117,7 +1322,7 @@ export const trezorWallet = createWallet({
         transports: resolvedTransports,
       });
 
-      const wallet = await getTrezorWallet({ chain, derivationPath });
+      const wallet = await getTrezorWallet({ address, chain, derivationPath });
 
       addChain({ ...wallet, chain, disconnect: disconnectTrezorSession, walletType });
 
@@ -1131,15 +1336,19 @@ export const trezorWallet = createWallet({
     [Chain.Berachain]: true,
     [Chain.BinanceSmartChain]: true,
     [Chain.Bitcoin]: true,
+    [Chain.BitcoinCash]: true,
+    [Chain.Dash]: true,
     [Chain.Ethereum]: true,
     [Chain.Gnosis]: true,
+    [Chain.Dogecoin]: true,
     [Chain.Litecoin]: true,
     [Chain.Monad]: true,
     [Chain.Optimism]: true,
     [Chain.Polygon]: true,
     [Chain.XLayer]: true,
-    // BCH/DASH/DOGE/ZEC: pending PSBT→TrezorConnect converter (V3 plan PR)
+    // ZEC: pending PCZT/TrezorConnect validation
   },
+  getExtendedPublicKey: getTrezorExtendedPublicKey,
   name: "connectTrezor",
   supportedChains: [
     Chain.Arbitrum,

package/dist/chunk-mrsfcest.js

@@ -1,4 +0,0 @@
-var A=require("@scure/base");async function E(q){let{RawTx:D}=await import("@swapkit/utxo-signer"),v=[];for(let j=0;j<q.inputsLength;j++){let f=q.getInput(j);if(!f.txid||f.index===void 0)throw Error(`PSBT input ${j} is missing txid/index`);let B=f.nonWitnessUtxo?A.hex.encode(D.encode(f.nonWitnessUtxo)):"",z=f.witnessUtxo?{script:f.witnessUtxo.script,value:Number(f.witnessUtxo.amount)}:void 0;v.push({hash:A.hex.encode(f.txid),index:f.index,txHex:B,value:z?.value??0,witnessUtxo:z})}return v}function G({legacyClient:q,chain:D,address:v}){return{getAddress:async()=>v,signTransaction:async(j)=>{let f=await E(j),B=await q.signTransaction(j,f),{Transaction:z}=await import("@swapkit/utxo-signer");return z.fromRaw(A.hex.decode(B))}}}
-
-//# debugId=E761B05D18A24EBF64756E2164756E21
-//# sourceMappingURL=chunk-mrsfcest.js.map

package/dist/chunk-mrsfcest.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/ledger/clients/utxo-legacy-adapter.ts"],
-  "sourcesContent": [
-    "import { hex } from \"@scure/base\";\nimport type { UTXOChain } from \"@swapkit/helpers\";\nimport type { UTXOType } from \"@swapkit/toolboxes/utxo\";\nimport type { Transaction } from \"@swapkit/utxo-signer\";\n\n/**\n * Extract per-input metadata from a V3 PSBT in the shape the legacy\n * `@ledgerhq/hw-app-btc.createPaymentTransaction` adapter expects.\n *\n * For segwit inputs the SwapKit V3 API populates `witnessUtxo`; for legacy\n * (BCH/DOGE/DASH) it populates `nonWitnessUtxo` with the full prior-tx bytes.\n * We re-encode the parsed `nonWitnessUtxo` back to hex via `RawTx.encode` so\n * `btcApp.splitTransaction(hex)` can consume it.\n *\n * Single-address account assumption: all inputs share our derivation path.\n */\nexport async function extractInputsFromPsbt(tx: Transaction): Promise<UTXOType[]> {\n  const { RawTx } = await import(\"@swapkit/utxo-signer\");\n  const inputs: UTXOType[] = [];\n\n  for (let i = 0; i < tx.inputsLength; i++) {\n    const input = tx.getInput(i);\n\n    if (!input.txid || input.index === undefined) {\n      throw new Error(`PSBT input ${i} is missing txid/index`);\n    }\n\n    const txHex = input.nonWitnessUtxo ? hex.encode(RawTx.encode(input.nonWitnessUtxo)) : \"\";\n    const witnessUtxo = input.witnessUtxo\n      ? { script: input.witnessUtxo.script, value: Number(input.witnessUtxo.amount) }\n      : undefined;\n\n    inputs.push({\n      hash: hex.encode(input.txid),\n      index: input.index,\n      txHex,\n      value: witnessUtxo?.value ?? 0,\n      witnessUtxo,\n    } as UTXOType);\n  }\n\n  return inputs;\n}\n\n/**\n * Build a toolbox-compatible signer from the existing legacy Ledger UTXO\n * client. The toolbox synthesizes `signAndBroadcastTransaction` on top of\n * `signer.signTransaction(tx) → Transaction`.\n */\nexport function createLegacyPsbtSigner({\n  legacyClient,\n  chain: _chain,\n  address,\n}: {\n  legacyClient: { signTransaction: (tx: Transaction, inputUtxos: UTXOType[]) => Promise<string> };\n  chain: UTXOChain;\n  address: string;\n}) {\n  return {\n    getAddress: async () => address,\n    signTransaction: async (tx: Transaction): Promise<Transaction> => {\n      const inputUtxos = await extractInputsFromPsbt(tx);\n      const signedTxHex = await legacyClient.signTransaction(tx, inputUtxos);\n\n      const { Transaction: TxClass } = await import(\"@swapkit/utxo-signer\");\n      // `Transaction.fromRaw` parses a serialised tx (no PSBT envelope) — exactly\n      // what `createPaymentTransaction` returns.\n      return TxClass.fromRaw(hex.decode(signedTxHex));\n    },\n  };\n}\n"
-  ],
-  "mappings": "AAAoB,IAApB,yBAgBA,eAAsB,CAAqB,CAAC,EAAsC,CAChF,IAAQ,SAAU,KAAa,gCACzB,EAAqB,CAAC,EAE5B,QAAS,EAAI,EAAG,EAAI,EAAG,aAAc,IAAK,CACxC,IAAM,EAAQ,EAAG,SAAS,CAAC,EAE3B,GAAI,CAAC,EAAM,MAAQ,EAAM,QAAU,OACjC,MAAU,MAAM,cAAc,yBAAyB,EAGzD,IAAM,EAAQ,EAAM,eAAiB,MAAI,OAAO,EAAM,OAAO,EAAM,cAAc,CAAC,EAAI,GAChF,EAAc,EAAM,YACtB,CAAE,OAAQ,EAAM,YAAY,OAAQ,MAAO,OAAO,EAAM,YAAY,MAAM,CAAE,EAC5E,OAEJ,EAAO,KAAK,CACV,KAAM,MAAI,OAAO,EAAM,IAAI,EAC3B,MAAO,EAAM,MACb,QACA,MAAO,GAAa,OAAS,EAC7B,aACF,CAAa,EAGf,OAAO,EAQF,SAAS,CAAsB,EACpC,eACA,MAAO,EACP,WAKC,CACD,MAAO,CACL,WAAY,SAAY,EACxB,gBAAiB,MAAO,IAA0C,CAChE,IAAM,EAAa,MAAM,EAAsB,CAAE,EAC3C,EAAc,MAAM,EAAa,gBAAgB,EAAI,CAAU,GAE7D,YAAa,GAAY,KAAa,gCAG9C,OAAO,EAAQ,QAAQ,MAAI,OAAO,CAAW,CAAC,EAElD",
-  "debugId": "E761B05D18A24EBF64756E2164756E21",
-  "names": []
-}

package/dist/chunk-px09mwnt.js

@@ -1,4 +0,0 @@
-import{d as E}from"./chunk-n05bv2n5.js";import{hex as B}from"@scure/base";async function G(q){let{RawTx:D}=await import("@swapkit/utxo-signer"),v=[];for(let j=0;j<q.inputsLength;j++){let f=q.getInput(j);if(!f.txid||f.index===void 0)throw Error(`PSBT input ${j} is missing txid/index`);let A=f.nonWitnessUtxo?B.encode(D.encode(f.nonWitnessUtxo)):"",z=f.witnessUtxo?{script:f.witnessUtxo.script,value:Number(f.witnessUtxo.amount)}:void 0;v.push({hash:B.encode(f.txid),index:f.index,txHex:A,value:z?.value??0,witnessUtxo:z})}return v}function K({legacyClient:q,chain:D,address:v}){return{getAddress:async()=>v,signTransaction:async(j)=>{let f=await G(j),A=await q.signTransaction(j,f),{Transaction:z}=await import("@swapkit/utxo-signer");return z.fromRaw(B.decode(A))}}}export{G as extractInputsFromPsbt,K as createLegacyPsbtSigner};
-
-//# debugId=95BF8F59DBE0DD4C64756E2164756E21
-//# sourceMappingURL=chunk-px09mwnt.js.map

package/dist/chunk-px09mwnt.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/ledger/clients/utxo-legacy-adapter.ts"],
-  "sourcesContent": [
-    "import { hex } from \"@scure/base\";\nimport type { UTXOChain } from \"@swapkit/helpers\";\nimport type { UTXOType } from \"@swapkit/toolboxes/utxo\";\nimport type { Transaction } from \"@swapkit/utxo-signer\";\n\n/**\n * Extract per-input metadata from a V3 PSBT in the shape the legacy\n * `@ledgerhq/hw-app-btc.createPaymentTransaction` adapter expects.\n *\n * For segwit inputs the SwapKit V3 API populates `witnessUtxo`; for legacy\n * (BCH/DOGE/DASH) it populates `nonWitnessUtxo` with the full prior-tx bytes.\n * We re-encode the parsed `nonWitnessUtxo` back to hex via `RawTx.encode` so\n * `btcApp.splitTransaction(hex)` can consume it.\n *\n * Single-address account assumption: all inputs share our derivation path.\n */\nexport async function extractInputsFromPsbt(tx: Transaction): Promise<UTXOType[]> {\n  const { RawTx } = await import(\"@swapkit/utxo-signer\");\n  const inputs: UTXOType[] = [];\n\n  for (let i = 0; i < tx.inputsLength; i++) {\n    const input = tx.getInput(i);\n\n    if (!input.txid || input.index === undefined) {\n      throw new Error(`PSBT input ${i} is missing txid/index`);\n    }\n\n    const txHex = input.nonWitnessUtxo ? hex.encode(RawTx.encode(input.nonWitnessUtxo)) : \"\";\n    const witnessUtxo = input.witnessUtxo\n      ? { script: input.witnessUtxo.script, value: Number(input.witnessUtxo.amount) }\n      : undefined;\n\n    inputs.push({\n      hash: hex.encode(input.txid),\n      index: input.index,\n      txHex,\n      value: witnessUtxo?.value ?? 0,\n      witnessUtxo,\n    } as UTXOType);\n  }\n\n  return inputs;\n}\n\n/**\n * Build a toolbox-compatible signer from the existing legacy Ledger UTXO\n * client. The toolbox synthesizes `signAndBroadcastTransaction` on top of\n * `signer.signTransaction(tx) → Transaction`.\n */\nexport function createLegacyPsbtSigner({\n  legacyClient,\n  chain: _chain,\n  address,\n}: {\n  legacyClient: { signTransaction: (tx: Transaction, inputUtxos: UTXOType[]) => Promise<string> };\n  chain: UTXOChain;\n  address: string;\n}) {\n  return {\n    getAddress: async () => address,\n    signTransaction: async (tx: Transaction): Promise<Transaction> => {\n      const inputUtxos = await extractInputsFromPsbt(tx);\n      const signedTxHex = await legacyClient.signTransaction(tx, inputUtxos);\n\n      const { Transaction: TxClass } = await import(\"@swapkit/utxo-signer\");\n      // `Transaction.fromRaw` parses a serialised tx (no PSBT envelope) — exactly\n      // what `createPaymentTransaction` returns.\n      return TxClass.fromRaw(hex.decode(signedTxHex));\n    },\n  };\n}\n"
-  ],
-  "mappings": "wCAAA,cAAS,oBAgBT,eAAsB,CAAqB,CAAC,EAAsC,CAChF,IAAQ,SAAU,KAAa,gCACzB,EAAqB,CAAC,EAE5B,QAAS,EAAI,EAAG,EAAI,EAAG,aAAc,IAAK,CACxC,IAAM,EAAQ,EAAG,SAAS,CAAC,EAE3B,GAAI,CAAC,EAAM,MAAQ,EAAM,QAAU,OACjC,MAAU,MAAM,cAAc,yBAAyB,EAGzD,IAAM,EAAQ,EAAM,eAAiB,EAAI,OAAO,EAAM,OAAO,EAAM,cAAc,CAAC,EAAI,GAChF,EAAc,EAAM,YACtB,CAAE,OAAQ,EAAM,YAAY,OAAQ,MAAO,OAAO,EAAM,YAAY,MAAM,CAAE,EAC5E,OAEJ,EAAO,KAAK,CACV,KAAM,EAAI,OAAO,EAAM,IAAI,EAC3B,MAAO,EAAM,MACb,QACA,MAAO,GAAa,OAAS,EAC7B,aACF,CAAa,EAGf,OAAO,EAQF,SAAS,CAAsB,EACpC,eACA,MAAO,EACP,WAKC,CACD,MAAO,CACL,WAAY,SAAY,EACxB,gBAAiB,MAAO,IAA0C,CAChE,IAAM,EAAa,MAAM,EAAsB,CAAE,EAC3C,EAAc,MAAM,EAAa,gBAAgB,EAAI,CAAU,GAE7D,YAAa,GAAY,KAAa,gCAG9C,OAAO,EAAQ,QAAQ,EAAI,OAAO,CAAW,CAAC,EAElD",
-  "debugId": "95BF8F59DBE0DD4C64756E2164756E21",
-  "names": []
-}