@swapkit/wallet-hardware 5.0.1 → 6.0.1

package/src/ledger/types.ts

@@ -1,42 +1,47 @@
+import type { BitcoinLedger } from "./clients/bitcoin";
 import type { CosmosLedger } from "./clients/cosmos";
 import type {
   ArbitrumLedger,
+  ArcLedger,
   AuroraLedger,
   AvalancheLedger,
   BaseLedger,
+  BerachainLedger,
   BinanceSmartChainLedger,
   EthereumLedger,
   GnosisLedger,
+  MonadLedger,
   OptimismLedger,
   PolygonLedger,
+  XLayerLedger,
 } from "./clients/evm";
 import type { SuiLedger } from "./clients/sui";
 import type { THORChainLedger } from "./clients/thorchain";
 import type { TronLedger } from "./clients/tron";
-import type { BitcoinCashLedger, BitcoinLedger, DogecoinLedger, LitecoinLedger } from "./clients/utxo";
+import type { BitcoinCashLedger, DashLedger, DogecoinLedger, LitecoinLedger } from "./clients/utxo";
+import type { ZcashLedger } from "./clients/zcash";
 
 export type UTXOLedgerClients =
   | ReturnType<typeof BitcoinLedger>
   | ReturnType<typeof BitcoinCashLedger>
+  | ReturnType<typeof DashLedger>
   | ReturnType<typeof DogecoinLedger>
-  | ReturnType<typeof LitecoinLedger>;
+  | ReturnType<typeof LitecoinLedger>
+  | ReturnType<typeof ZcashLedger>;
 export type CosmosLedgerClients = CosmosLedger | THORChainLedger;
 export type EVMLedgerClients =
   | ReturnType<typeof ArbitrumLedger>
+  | ReturnType<typeof ArcLedger>
   | ReturnType<typeof AuroraLedger>
   | ReturnType<typeof AvalancheLedger>
   | ReturnType<typeof BaseLedger>
+  | ReturnType<typeof BerachainLedger>
   | ReturnType<typeof BinanceSmartChainLedger>
   | ReturnType<typeof GnosisLedger>
   | ReturnType<typeof EthereumLedger>
+  | ReturnType<typeof MonadLedger>
   | ReturnType<typeof OptimismLedger>
-  | ReturnType<typeof PolygonLedger>;
+  | ReturnType<typeof PolygonLedger>
+  | ReturnType<typeof XLayerLedger>;
 export type TronLedgerClient = ReturnType<typeof TronLedger>;
 export type SuiLedgerClient = ReturnType<typeof SuiLedger>;
-
-export type GetAddressAndPubKeyResponse = {
-  bech32_address: string;
-  compressed_pk: any;
-  error_message: string;
-  return_code: number;
-};

package/src/trezor/index.ts

@@ -1,3 +1,4 @@
+import { hex } from "@scure/base";
 import { HDKey, type Versions } from "@scure/bip32";
 import {
   Chain,
@@ -24,12 +25,12 @@ import {
   type UTXOType,
 } from "@swapkit/toolboxes/utxo";
 import type { BTCNetwork, PCZT, Transaction, ZcashPSBT, ZcashTransaction } from "@swapkit/utxo-signer";
-import { BCHSigHash, NETWORKS, ZcashVersionGroupId } from "@swapkit/utxo-signer";
 import { createWallet, getWalletSupportedChains, type HardwareExtendedPublicKeyInfo } from "@swapkit/wallet-core";
 
 import { applyMissingSpendingMetadata } from "../helpers/psbt";
 
 type TrezorBip32Derivation = [Uint8Array, { fingerprint: number; path: number[] }];
+type TrezorTapBip32Derivation = [Uint8Array, { der: { fingerprint: number; path: number[] }; hashes: Uint8Array[] }];
 type TrezorCoreMode = "auto" | "iframe" | "popup" | "suite-desktop" | "suite-web";
 type TrezorTransport = "BridgeTransport" | "WebUsbTransport" | "NodeUsbTransport";
 type ConnectTrezorOptions = { address?: string };
@@ -52,15 +53,12 @@ const DEFAULT_TREZOR_CORE_MODE: TrezorCoreMode = "auto";
 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 BITCOIN_CASH_SIGHASH_ALL = 0x41;
 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,
-];
+const EXTENDED_KEY_VERSION_CANDIDATES = (
+  [Chain.Bitcoin, Chain.BitcoinCash, Chain.Dash, Chain.Dogecoin, Chain.Litecoin] as const satisfies readonly UTXOChain[]
+).map((chain) => getNetworkForChain(chain).bip32);
 
 async function disconnectTrezorSession() {
   trezorXpubCache.clear();
@@ -201,15 +199,63 @@ function tryNormalizeTrezorExtendedPublicKey(xpub: string | undefined, chain: UT
   }
 }
 
-function decodeOpReturnData(script: Uint8Array): string | null {
-  if (script.length < 2 || script[0] !== 0x6a) return null;
-  const dataLen = script[1];
-  if (dataLen === undefined || script.length < 2 + dataLen) return null;
-  return Buffer.from(script.slice(2, 2 + dataLen)).toString("hex");
+async function decodeOpReturnData(script: Uint8Array) {
+  const { Script } = await import("@swapkit/utxo-signer");
+
+  try {
+    const [opcode, data] = Script.decode(script);
+    const bytes = data === 0 ? new Uint8Array() : data;
+    if (opcode !== "RETURN" || !(bytes instanceof Uint8Array)) return null;
+
+    // Trezor rebuilds the script from the data, so only accept scripts it reproduces byte for byte
+    return hex.encode(Script.encode(["RETURN", bytes])) === hex.encode(script) ? hex.encode(bytes) : null;
+  } catch {
+    return null;
+  }
+}
+
+async function toTrezorOpReturnOutput(script: Uint8Array, amount: bigint | undefined, chain: Chain) {
+  if (amount !== 0n) {
+    throw new SwapKitError({
+      errorKey: "wallet_trezor_failed_to_sign_transaction",
+      info: { chain, error: "OP_RETURN output carrying value cannot be signed" },
+    });
+  }
+
+  const opReturnData = await decodeOpReturnData(script);
+
+  if (opReturnData === null) {
+    throw new SwapKitError({
+      errorKey: "wallet_trezor_failed_to_sign_transaction",
+      info: { chain, error: "Malformed OP_RETURN output cannot be signed" },
+    });
+  }
+
+  return { amount: "0", op_return_data: opReturnData, script_type: "PAYTOOPRETURN" as const };
+}
+
+async function assertTransactionCarriesMemo(tx: Transaction, memo: string, chain: Chain) {
+  if (!memo) return;
+
+  const expected = hex.encode(new TextEncoder().encode(memo));
+
+  for (let i = 0; i < tx.outputsLength; i++) {
+    const script = tx.getOutput(i).script;
+    if (script?.[0] === 0x6a && (await decodeOpReturnData(script)) === expected) return;
+  }
+
+  throw new SwapKitError({
+    errorKey: "wallet_trezor_failed_to_sign_transaction",
+    info: { chain, error: "Transaction does not carry the provided memo" },
+  });
 }
 
-function getScriptType(derivationPath: DerivationPathArray) {
+function getScriptType(chain: Chain, derivationPath: DerivationPathArray) {
   switch (derivationPath[0]) {
+    case 86:
+      return chain === Chain.Bitcoin
+        ? ({ input: "SPENDTAPROOT", output: "PAYTOTAPROOT", utxo: UTXOScriptType.P2TR } as const)
+        : null;
     case 84:
       return { input: "SPENDWITNESS", output: "PAYTOWITNESS", utxo: UTXOScriptType.P2WPKH } as const;
     case 49:
@@ -245,6 +291,37 @@ function getFirstBip32Derivation(input: { bip32Derivation?: unknown }): TrezorBi
   return isTrezorBip32Derivation(firstDerivation) ? firstDerivation : undefined;
 }
 
+function isTrezorTapBip32Derivation(value: unknown): value is TrezorTapBip32Derivation {
+  if (!(Array.isArray(value) && value[0] instanceof Uint8Array)) return false;
+  const origin = value[1] as { der?: { path?: unknown }; hashes?: unknown } | undefined;
+
+  return Array.isArray(origin?.hashes) && Array.isArray(origin?.der?.path);
+}
+
+// Key-path origins carry no leaf hashes; take the one for the internal key, or the only one when it is unset.
+function selectTapKeyOrigin(input: { tapBip32Derivation?: unknown; tapInternalKey?: Uint8Array }, inputIndex: number) {
+  const origins = Array.isArray(input.tapBip32Derivation) ? input.tapBip32Derivation : [];
+  if (origins.length === 0) return undefined;
+
+  const { tapInternalKey } = input;
+  const keyPathOrigins = origins.filter(
+    (origin): origin is TrezorTapBip32Derivation =>
+      isTrezorTapBip32Derivation(origin) &&
+      origin[1].hashes.length === 0 &&
+      (!tapInternalKey || hex.encode(origin[0]) === hex.encode(tapInternalKey)),
+  );
+  const [xOnlyKey, origin] = keyPathOrigins[0] ?? [];
+
+  if (keyPathOrigins.length !== 1 || !(xOnlyKey && origin)) {
+    throw new SwapKitError({
+      errorKey: "wallet_trezor_failed_to_sign_transaction",
+      info: { chain: Chain.Bitcoin, error: `Input ${inputIndex} has no single taproot key-path origin to sign with` },
+    });
+  }
+
+  return { path: origin.der.path, xOnlyKey };
+}
+
 function getPrevoutAmount(input: {
   index?: number;
   nonWitnessUtxo?: { outputs?: Array<{ amount?: bigint | number }> };
@@ -263,7 +340,7 @@ export function normalizeTrezorSignature(signatureHex: string, chain: Chain) {
   const derLength = signature[1] !== undefined ? signature[1] + 2 : undefined;
 
   if (derLength !== undefined && signature.length === derLength) {
-    return new Uint8Array([...signature, chain === Chain.BitcoinCash ? BCHSigHash.ALL : 0x01]);
+    return new Uint8Array([...signature, chain === Chain.BitcoinCash ? BITCOIN_CASH_SIGHASH_ALL : 0x01]);
   }
 
   return new Uint8Array(signature);
@@ -294,16 +371,9 @@ async function buildPCZTOutputsForTrezor(pczt: PCZT, address_n: number[], myAddr
     const output = pczt.getOutput(i);
     const script = output.scriptPubkey;
 
-    if (output.value === 0n && script?.length > 0 && script[0] === 0x6a) {
-      const opReturnData = decodeOpReturnData(script);
-      if (opReturnData) {
-        outputs.push({ amount: "0", op_return_data: opReturnData, script_type: "PAYTOOPRETURN" as const });
-        continue;
-      }
-      throw new SwapKitError({
-        errorKey: "wallet_trezor_failed_to_sign_transaction",
-        info: { chain, error: "Malformed OP_RETURN output cannot be signed" },
-      });
+    if (script?.[0] === 0x6a) {
+      outputs.push(await toTrezorOpReturnOutput(script, output.value, chain));
+      continue;
     }
 
     const outputAddress = await decodeOutputAddress(script);
@@ -328,7 +398,7 @@ async function buildPCZTOutputsForTrezor(pczt: PCZT, address_n: number[], myAddr
 
 async function decodeOutputAddress(script: Uint8Array): Promise<string | undefined> {
   try {
-    const { OutScript, Address } = await import("@swapkit/utxo-signer");
+    const { OutScript, Address, NETWORKS } = await import("@swapkit/utxo-signer");
     const decoded = OutScript.decode(script);
     if (decoded.type === "pkh" || decoded.type === "pk") {
       return Address(NETWORKS.zcash).encode(decoded);
@@ -378,19 +448,27 @@ function buildZcashTxInputsForTrezor(
   return inputs;
 }
 
-function buildZcashTxOutputsForTrezor(tx: ZcashTransaction, address_n: number[], myAddress: string, chain: Chain) {
+async function buildZcashTxOutputsForTrezor({
+  addressN,
+  chain,
+  myAddress,
+  network,
+  tx,
+}: {
+  addressN: number[];
+  chain: Chain;
+  myAddress: string;
+  network: BTCNetwork;
+  tx: ZcashTransaction;
+}) {
   const outputs = [];
   for (let i = 0; i < tx.outputsLength; i++) {
     const output = tx.getOutput(i);
-    const outputAddress = tx.getOutputAddress(i, NETWORKS.zcash);
+    const outputAddress = tx.getOutputAddress(i, network);
     const script = output.script;
 
-    if (output.amount === 0n && script?.length > 0 && script[0] === 0x6a) {
-      const opReturnData = decodeOpReturnData(script);
-      if (opReturnData) {
-        outputs.push({ amount: "0", op_return_data: opReturnData, script_type: "PAYTOOPRETURN" as const });
-        continue;
-      }
+    if (script?.[0] === 0x6a) {
+      outputs.push(await toTrezorOpReturnOutput(script, output.amount, chain));
       continue;
     }
 
@@ -402,18 +480,17 @@ function buildZcashTxOutputsForTrezor(tx: ZcashTransaction, address_n: number[],
     }
 
     const isChangeAddress = outputAddress === myAddress;
-    const outputParam = isChangeAddress || !outputAddress ? { address_n } : { address: outputAddress };
+    const outputParam = isChangeAddress || !outputAddress ? { address_n: addressN } : { address: outputAddress };
     outputs.push({ ...outputParam, amount: output.amount?.toString() || "0", script_type: "PAYTOADDRESS" as const });
   }
   return outputs;
 }
 
-function buildUtxoOutputsForTrezor(
+async function buildUtxoOutputsForTrezor(
   tx: Transaction,
   network: BTCNetwork,
   address_n: number[],
   myAddress: string,
-  memo: string,
   chain: Chain,
   scriptType: { input: string; output: string },
   toCashAddress: (addr: string) => string,
@@ -424,17 +501,12 @@ function buildUtxoOutputsForTrezor(
     const output = tx.getOutput(i);
     const outputAddress = tx.getOutputAddress(i, network);
 
-    if (!outputAddress) {
-      const opReturnData = output.script ? decodeOpReturnData(output.script) : null;
-      if (opReturnData !== null || memo) {
-        outputs.push({
-          amount: "0",
-          op_return_data: opReturnData ?? Buffer.from(memo).toString("hex"),
-          script_type: "PAYTOOPRETURN",
-        });
-        continue;
-      }
+    if (output.script?.[0] === 0x6a) {
+      outputs.push(await toTrezorOpReturnOutput(output.script, output.amount, chain));
+      continue;
+    }
 
+    if (!outputAddress) {
       throw new SwapKitError({
         errorKey: "wallet_trezor_failed_to_sign_transaction",
         info: { chain, error: "Unable to decode output address from scriptPubkey" },
@@ -509,9 +581,11 @@ async function getTrezorWallet<T extends Chain>({
     case Chain.BinanceSmartChain:
     case Chain.Ethereum:
     case Chain.Gnosis:
+    case Chain.Hyperevm:
     case Chain.Monad:
     case Chain.Optimism:
     case Chain.Polygon:
+    case Chain.Robinhood:
     case Chain.XLayer: {
       const { getProvider, getEvmToolboxAsync } = await import("@swapkit/toolboxes/evm");
       const { getEVMSigner } = await import("./evmSigner");
@@ -586,10 +660,17 @@ async function getTrezorWallet<T extends Chain>({
       const signZcashTransactionWithSerializedTx = async (tx: ZcashTransaction) => {
         const TrezorConnect = (await import("@trezor/connect-web")).default;
         const { hex: hexEncode } = await import("@scure/base");
+        const { NETWORKS, ZcashVersionGroupId } = await import("@swapkit/utxo-signer");
         const address_n = hardenDerivationPath(derivationPath);
 
         const inputs = buildZcashTxInputsForTrezor(tx, [], address_n, hexEncode);
-        const outputs = buildZcashTxOutputsForTrezor(tx, address_n, address, chain);
+        const outputs = await buildZcashTxOutputsForTrezor({
+          addressN: address_n,
+          chain,
+          myAddress: address,
+          network: NETWORKS.zcash,
+          tx,
+        });
 
         const result = await TrezorConnect.signTransaction({
           branchId: tx.consensusBranchId,
@@ -686,13 +767,14 @@ async function getTrezorWallet<T extends Chain>({
     case Chain.Litecoin: {
       const { toCashAddress, getUtxoToolbox, stripPrefix } = await import("@swapkit/toolboxes/utxo");
       const utxoChain = chain as UTXOChain;
-      const scriptType = getScriptType(derivationPath);
+      const scriptType = getScriptType(chain, derivationPath);
 
       if (!scriptType) {
         throw new SwapKitError({ errorKey: "wallet_trezor_derivation_path_not_supported", info: { derivationPath } });
       }
 
       const resolvedScriptType = scriptType;
+      const isTaproot = scriptType.utxo === UTXOScriptType.P2TR;
       const toolboxParams = { scriptType: scriptType.utxo };
       const coin = chain.toLowerCase();
 
@@ -724,16 +806,17 @@ async function getTrezorWallet<T extends Chain>({
       const baseToolbox = getUtxoToolbox(chain, toolboxParams);
 
       const signTransaction = async (tx: Transaction, inputs: UTXOType[], memo = "") => {
+        await assertTransactionCarriesMemo(tx, memo, chain);
+
         const TrezorConnect = (await import("@trezor/connect-web")).default;
         const address_n = hardenDerivationPath(derivationPath);
         const network = getNetworkForChain(chain as UTXOChain);
 
-        const outputs = buildUtxoOutputsForTrezor(
+        const outputs = await buildUtxoOutputsForTrezor(
           tx,
           network,
           address_n,
           address,
-          memo,
           chain,
           resolvedScriptType,
           toCashAddress,
@@ -795,10 +878,37 @@ async function getTrezorWallet<T extends Chain>({
         const signerPubkeys: Uint8Array[] = [];
         const trezorInputs = [];
 
-        for (let inputIndex = 0; inputIndex < tx.inputsLength; inputIndex++) {
-          const input = tx.getInput(inputIndex);
+        async function prepareInputForSigning(inputIndex: number, input: ReturnType<Transaction["getInput"]>) {
+          if (isTaproot) {
+            let keyOrigin = selectTapKeyOrigin(input, inputIndex);
+
+            if (!keyOrigin) {
+              const [publicKey, { path }] = await getFallbackDerivation();
+              keyOrigin = { path, xOnlyKey: publicKey.slice(1) };
+              tx.updateInput(inputIndex, {
+                tapBip32Derivation: [[keyOrigin.xOnlyKey, { der: { fingerprint: 0, path }, hashes: [] }]],
+              });
+            }
+
+            // A BIP86 key-path input's internal key is the x-only key its origin names.
+            if (!input.tapInternalKey) tx.updateInput(inputIndex, { tapInternalKey: keyOrigin.xOnlyKey });
+            return keyOrigin.path;
+          }
+
           const existingDerivation = getFirstBip32Derivation(input);
           const derivation = existingDerivation ?? (await getFallbackDerivation());
+          signerPubkeys[inputIndex] = derivation[0];
+
+          if (!existingDerivation) {
+            tx.updateInput(inputIndex, { bip32Derivation: [derivation] });
+          }
+
+          await applyMissingSpendingMetadata({ chain: utxoChain, indexes: [inputIndex], publicKey: derivation[0], tx });
+          return derivation[1].path;
+        }
+
+        for (let inputIndex = 0; inputIndex < tx.inputsLength; inputIndex++) {
+          const input = tx.getInput(inputIndex);
           const amount = getPrevoutAmount(input);
 
           if (!input.txid || input.index === undefined || !amount) {
@@ -808,16 +918,10 @@ async function getTrezorWallet<T extends Chain>({
             });
           }
 
-          signerPubkeys[inputIndex] = derivation[0];
-
-          if (!existingDerivation) {
-            tx.updateInput(inputIndex, { bip32Derivation: [derivation] });
-          }
-
-          await applyMissingSpendingMetadata({ chain: utxoChain, indexes: [inputIndex], publicKey: derivation[0], tx });
+          const inputAddressN = await prepareInputForSigning(inputIndex, input);
 
           trezorInputs.push({
-            address_n: derivation[1].path,
+            address_n: inputAddressN,
             amount,
             prev_hash: hexEncode.encode(input.txid),
             prev_index: input.index,
@@ -826,12 +930,11 @@ async function getTrezorWallet<T extends Chain>({
           });
         }
 
-        const outputs = buildUtxoOutputsForTrezor(
+        const outputs = await buildUtxoOutputsForTrezor(
           tx,
           network,
           address_n,
           address,
-          "",
           chain,
           resolvedScriptType,
           toCashAddress,
@@ -856,8 +959,16 @@ async function getTrezorWallet<T extends Chain>({
         }
 
         result.payload.signatures.forEach((signatureHex, inputIndex) => {
+          if (!signatureHex) return;
+
+          // Taproot key-path signatures are Schnorr, not DER, and finalize from tapKeySig.
+          if (isTaproot) {
+            tx.updateInput(inputIndex, { tapKeySig: hexEncode.decode(signatureHex) });
+            return;
+          }
+
           const pubkey = signerPubkeys[inputIndex];
-          if (!(signatureHex && pubkey)) return;
+          if (!pubkey) return;
 
           tx.updateInput(inputIndex, { partialSig: [[pubkey, normalizeTrezorSignature(signatureHex, chain)]] });
         });
@@ -893,12 +1004,11 @@ async function getTrezorWallet<T extends Chain>({
           });
         }
 
-        const outputs = buildUtxoOutputsForTrezor(
+        const outputs = await buildUtxoOutputsForTrezor(
           tx,
           network,
           address_n,
           address,
-          "",
           chain,
           resolvedScriptType,
           toCashAddress,
@@ -936,16 +1046,17 @@ async function getTrezorWallet<T extends Chain>({
         }>,
         memo = "",
       ) => {
+        await assertTransactionCarriesMemo(tx, memo, chain);
+
         const TrezorConnect = (await import("@trezor/connect-web")).default;
         const network = getNetworkForChain(chain as UTXOChain);
         const baseAddressN = hardenDerivationPath(derivationPath.slice(0, 3) as unknown as DerivationPathArray);
 
-        const outputs = buildUtxoOutputsForTrezor(
+        const outputs = await buildUtxoOutputsForTrezor(
           tx,
           network,
           baseAddressN,
           address,
-          memo,
           chain,
           resolvedScriptType,
           toCashAddress,
@@ -1378,10 +1489,12 @@ export const trezorWallet = createWallet({
     [Chain.Ethereum]: true,
     [Chain.Gnosis]: true,
     [Chain.Dogecoin]: true,
+    [Chain.Hyperevm]: true,
     [Chain.Litecoin]: true,
     [Chain.Monad]: true,
     [Chain.Optimism]: true,
     [Chain.Polygon]: true,
+    [Chain.Robinhood]: true,
     [Chain.XLayer]: true,
     [Chain.Zcash]: true,
   },
@@ -1401,10 +1514,12 @@ export const trezorWallet = createWallet({
     Chain.Dogecoin,
     Chain.Ethereum,
     Chain.Gnosis,
+    Chain.Hyperevm,
     Chain.Litecoin,
     Chain.Monad,
     Chain.Optimism,
     Chain.Polygon,
+    Chain.Robinhood,
     Chain.XLayer,
     Chain.Zcash,
   ],

package/dist/chunk-1jpcb30j.js

@@ -1,5 +0,0 @@
-var d=((a)=>typeof require<"u"?require:typeof Proxy<"u"?new Proxy(a,{get:(b,c)=>(typeof require<"u"?require:b)[c]}):a)(function(a){if(typeof require<"u")return require.apply(this,arguments);throw Error('Dynamic require of "'+a+'" is not supported')});
-export{d as e};
-
-//# debugId=C12E7419EA3375B964756E2164756E21
-//# sourceMappingURL=chunk-1jpcb30j.js.map

package/dist/chunk-20wx60bn.js

@@ -1,4 +0,0 @@
-import{e as Q}from"./chunk-1jpcb30j.js";import{ChainToChainId as b,derivationPathToString as $,SwapKitError as J,WalletOption as K}from"@swapkit/helpers";async function G({chain:_,derivationPath:C,provider:I}){let{AbstractSigner:f}=await import("ethers");class N extends f{address;chain;derivationPath;provider;constructor({chain:j,derivationPath:q,provider:B}){super(B);this.address="",this.chain=j,this.derivationPath=q,this.provider=B}getAddress=async()=>{if(!this.address){let q=await(await import("@trezor/connect-web")).default.ethereumGetAddress({path:$(this.derivationPath),showOnTrezor:!0});if(!q.success)throw new J({errorKey:"wallet_trezor_failed_to_get_address",info:{...q,chain:this.chain,derivationPath:this.derivationPath}});this.address=q.payload.address}return this.address};signMessage=async(j)=>{let B=await(await import("@trezor/connect-web")).default.ethereumSignMessage({message:j,path:$(this.derivationPath)});if(!B.success)throw new J({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{...B,chain:this.chain,derivationPath:this.derivationPath,message:j}});return B.payload.signature};signTypedData=async(j,q,B,O)=>{let W=(await import("@trezor/connect-web")).default,{buildEIP712DomainType:U}=await import("@swapkit/toolboxes/evm"),{TypedDataEncoder:Z}=await import("ethers"),{EIP712Domain:X,...V}=q,A=O??Z.from(V).primaryType,M=U(j),D={domain:j,message:B,primaryType:A,types:{EIP712Domain:M,...V}},R=await W.ethereumSignTypedData({data:D,metamask_v4_compat:!0,path:$(this.derivationPath)});if(!R.success)throw new J({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:this.chain,error:R.payload.error}});return R.payload.signature.startsWith("0x")?R.payload.signature:`0x${R.payload.signature}`};signTransaction=async({to:j,gasLimit:q,value:B,data:O,nonce:W,maxFeePerGas:U,maxPriorityFeePerGas:Z,gasPrice:X})=>{if(!j)throw new J({errorKey:"wallet_missing_params",info:{to:j}});if(!q)throw new J({errorKey:"wallet_missing_params",info:{gasLimit:q}});let V=U!=null||Z!=null;if(V&&!U)throw new J({errorKey:"wallet_missing_params",info:{maxFeePerGas:U}});if(!(V||X))throw new J({errorKey:"wallet_missing_params",info:{gasPrice:X}});let A=(await import("@trezor/connect-web")).default,{toHexString:M}=await import("@swapkit/toolboxes/evm"),D=V?{maxFeePerGas:M(BigInt(U?.toString()||0)),maxPriorityFeePerGas:M(BigInt(Z?.toString()||0))}:X&&{gasPrice:M(BigInt(X?.toString()||0))}||{gasPrice:"0x0"},R=M(BigInt(W||await this.provider.getTransactionCount(await this.getAddress(),"pending"))),H={chainId:Number.parseInt(b[this.chain],10),data:O?.toString()||"0x",gasLimit:M(BigInt(q?.toString()||0)),nonce:R,to:j.toString(),value:M(BigInt(B?.toString()||0)),...D},{success:L,payload:Y}=await A.ethereumSignTransaction({path:$(this.derivationPath),transaction:H});if(!L)throw new J({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{...Y,chain:this.chain,derivationPath:this.derivationPath}});let k=Y.serializedTx?Y.serializedTx.startsWith("0x")?Y.serializedTx:`0x${Y.serializedTx}`:void 0;if(!k)throw new J({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:this.chain,derivationPath:this.derivationPath}});return k};connect=(j)=>{if(!j)throw new J({errorKey:"wallet_provider_not_found",info:{chain:this.chain,derivationPath:this.derivationPath,wallet:K.TREZOR}});return new N({chain:this.chain,derivationPath:this.derivationPath,provider:j})}}return new N({chain:_,derivationPath:C,provider:I})}export{G as getEVMSigner};
-
-//# debugId=52F319863E87D75D64756E2164756E21
-//# sourceMappingURL=chunk-20wx60bn.js.map

package/dist/chunk-4tbtxdxa.js

@@ -1,5 +0,0 @@
-import{e as s}from"./chunk-1jpcb30j.js";async function d({chain:t,indexes:a,publicKey:i,tx:n}){let{getMissingSpendingMetadata:e,getNetworkForChain:o}=await import("@swapkit/toolboxes/utxo");for(let{index:r,...p}of e({chain:t,indexes:a,network:o(t),publicKey:i,tx:n}))n.updateInput(r,p)}
-export{d};
-
-//# debugId=400A1FA50F54FC1E64756E2164756E21
-//# sourceMappingURL=chunk-4tbtxdxa.js.map

package/dist/chunk-7v7cgm69.js

@@ -1,4 +0,0 @@
-import{c as v}from"./chunk-83g13ck6.js";import{d as C}from"./chunk-4tbtxdxa.js";import{e as k}from"./chunk-1jpcb30j.js";import{base64 as P}from"@scure/base";import{HDKey as g}from"@scure/bip32";import{Chain as S,derivationPathToString as x,getWalletFormatFor as l,SwapKitError as F}from"@swapkit/helpers";var u={bitcoin:S.Bitcoin,litecoin:S.Litecoin};function s(G){switch(G){case"bech32":return"wpkh(@0/**)";case"p2sh":return"sh(wpkh(@0/**))";case"legacy":return"pkh(@0/**)";default:return"wpkh(@0/**)"}}function c(G){return typeof G==="string"?G:x(G)}function T(G){return G.replace(/^m\//,"").replace(/^\/+/,"")}function h(G){return G.replace(/^m\//,"").split("/").filter(Boolean).map((J)=>{let V=J.endsWith("'"),Z=Number.parseInt(V?J.slice(0,-1):J,10);return V?(Z|2147483648)>>>0:Z})}function o(G){for(let J=0;J<G.inputsLength;J++){let V=G.getInput(J);if(V.nonWitnessUtxo&&V.witnessUtxo)G.updateInput(J,{witnessUtxo:void 0})}}function d(G,J){let V=G.getInput(J);return Boolean(V.bip32Derivation?.length)}var L=({chain:G})=>{return(J,V)=>{let Z,w;async function j(){if(!Z){let q=V??await v(),{AppClient:Q}=await import("ledger-bitcoin");Z=new Q(q)}return Z}async function A(){if(!w)w=await(await j()).getMasterFingerprint();return w}let z=T(J?c(J):"84'/0'/0'/0/0"),U=z.split("/").filter(Boolean),E=U.slice(0,3).join("/"),O=U.slice(3),B=Number(O[0]??0),D=Number(O[1]??0),H=l(`m/${z}`),I=s(H),M,K;async function W(){let q=await j(),Q=await A();if(!M)M=await q.getExtendedPubkey(`m/${E}`);let{DefaultWalletPolicy:Y}=await import("ledger-bitcoin"),N=new Y(I,`[${Q}/${E}]${M}`);return{app:q,fpr:Q,policy:N,xpub:M}}async function _(){if(!K){let{xpub:q}=await W(),Y=g.fromExtendedKey(q).derive(`m/${B}/${D}`);if(!Y.publicKey)throw new F("wallet_ledger_get_address_error",{message:`Cannot derive leaf pubkey for ${G}`});K=Y.publicKey}return K}return{connect:async()=>{await j()},getAddress:async()=>{let{app:q,policy:Q}=await W(),Y=await q.getWalletAddress(Q,null,B,D,!1);if(!Y)throw new F("wallet_ledger_get_address_error",{message:`Cannot get ${G} address from ledger derivation path: ${z}`});return Y},getExtendedPublicKey:async(q=`m/${E}`)=>{return(await j()).getExtendedPubkey(`m/${T(q)}`)},getPublicKey:_,signTransaction:async(q)=>{let{app:Q,policy:Y,fpr:N}=await W(),f=Number.parseInt(N,16)>>>0,y=h(z),X=Array.from({length:q.inputsLength},($,R)=>R).filter(($)=>!d(q,$));if(X.length>0){let $=await _();for(let R of X)q.updateInput(R,{bip32Derivation:[[$,{fingerprint:f,path:y}]]})}if(H==="legacy")o(q);if(H==="p2sh")await C({chain:u[G],publicKey:await _(),tx:q});let m=P.encode(q.toPSBT(0)),b=await Q.signPsbt(m,Y,null);for(let[$,R]of b)q.updateInput($,{partialSig:[[new Uint8Array(R.pubkey),new Uint8Array(R.signature)]]});return q}}}},e=L({chain:"bitcoin"}),t=L({chain:"litecoin"});export{t as LitecoinPsbtLedger,e as BitcoinPsbtLedger};
-
-//# debugId=196AC9353D4ED98464756E2164756E21
-//# sourceMappingURL=chunk-7v7cgm69.js.map

package/dist/chunk-7v7cgm69.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/ledger/clients/utxo-psbt.ts"],
-  "sourcesContent": [
-    "import type Transport from \"@ledgerhq/hw-transport\";\nimport { base64 } from \"@scure/base\";\nimport { HDKey } from \"@scure/bip32\";\nimport {\n  Chain,\n  type DerivationPathArray,\n  derivationPathToString,\n  getWalletFormatFor,\n  SwapKitError,\n  type UTXOChain,\n} from \"@swapkit/helpers\";\nimport type { Transaction } from \"@swapkit/utxo-signer\";\n\nimport { applyMissingSpendingMetadata } from \"../../helpers/psbt\";\nimport { getLedgerTransport } from \"../helpers/getLedgerTransport\";\n\ntype SupportedCoin = \"bitcoin\" | \"litecoin\";\n\nconst UTXO_CHAIN_FOR_COIN: Record<SupportedCoin, UTXOChain> = { bitcoin: Chain.Bitcoin, litecoin: Chain.Litecoin };\n\ntype DefaultDescriptorTemplate = \"wpkh(@0/**)\" | \"tr(@0/**)\" | \"sh(wpkh(@0/**))\" | \"pkh(@0/**)\";\n\nfunction templateForFormat(format: ReturnType<typeof getWalletFormatFor>): DefaultDescriptorTemplate {\n  switch (format) {\n    case \"bech32\":\n      return \"wpkh(@0/**)\";\n    case \"p2sh\":\n      return \"sh(wpkh(@0/**))\";\n    case \"legacy\":\n      return \"pkh(@0/**)\";\n    default:\n      return \"wpkh(@0/**)\";\n  }\n}\n\nfunction pathToString(path: DerivationPathArray | string): string {\n  return typeof path === \"string\" ? path : derivationPathToString(path);\n}\n\nfunction normalizeLedgerPath(path: string): string {\n  return path.replace(/^m\\//, \"\").replace(/^\\/+/, \"\");\n}\n\nfunction pathToNumberArray(path: string): number[] {\n  return path\n    .replace(/^m\\//, \"\")\n    .split(\"/\")\n    .filter(Boolean)\n    .map((p) => {\n      const hardened = p.endsWith(\"'\");\n      const num = Number.parseInt(hardened ? p.slice(0, -1) : p, 10);\n      return hardened ? (num | 0x80000000) >>> 0 : num;\n    });\n}\n\nfunction dropWitnessUtxoFromLegacyInputs(tx: Transaction) {\n  for (let inputIndex = 0; inputIndex < tx.inputsLength; inputIndex++) {\n    const input = tx.getInput(inputIndex);\n\n    if (input.nonWitnessUtxo && input.witnessUtxo) {\n      tx.updateInput(inputIndex, { witnessUtxo: undefined });\n    }\n  }\n}\n\nfunction hasBip32Derivation(tx: Transaction, inputIndex: number) {\n  const input = tx.getInput(inputIndex) as { bip32Derivation?: Array<unknown> };\n\n  return Boolean(input.bip32Derivation?.length);\n}\n\nconst BaseLedgerPsbtUTXO = ({ chain }: { chain: SupportedCoin }) => {\n  return (derivationPathArray?: DerivationPathArray | string, injectedTransport?: Transport) => {\n    // Per-call state — each BitcoinPsbtLedger/LitecoinPsbtLedger invocation has its own\n    // AppClient and master fingerprint so different consumers (e.g. concurrent MCP\n    // sessions on different devices) cannot inherit each other's ledger bindings or xpub.\n    let appClient: import(\"ledger-bitcoin\").AppClient | undefined;\n    let masterFingerprint: string | undefined;\n\n    async function getAppClient() {\n      if (!appClient) {\n        const transport = injectedTransport ?? (await getLedgerTransport());\n        const { AppClient } = await import(\"ledger-bitcoin\");\n        appClient = new AppClient(transport);\n      }\n      return appClient;\n    }\n\n    async function getFingerprint() {\n      if (!masterFingerprint) {\n        const app = await getAppClient();\n        masterFingerprint = await app.getMasterFingerprint();\n      }\n      return masterFingerprint;\n    }\n\n    // Single-address account: change == index == 0 by default.\n    const derivationPath = normalizeLedgerPath(\n      derivationPathArray ? pathToString(derivationPathArray) : \"84'/0'/0'/0/0\",\n    );\n    const pathSegments = derivationPath.split(\"/\").filter(Boolean);\n    const accountPath = pathSegments.slice(0, 3).join(\"/\");\n    const leafSegments = pathSegments.slice(3);\n    const change = Number(leafSegments[0] ?? 0);\n    const addressIndex = Number(leafSegments[1] ?? 0);\n    // getWalletFormatFor expects an m/-prefixed path (it reads the purpose\n    // from the second segment); derivationPath is normalized without it.\n    const format = getWalletFormatFor(`m/${derivationPath}`);\n    const template = templateForFormat(format);\n\n    let cachedAccountXpub: string | undefined;\n    let cachedLeafPubkey: Uint8Array | undefined;\n\n    async function buildPolicy() {\n      const app = await getAppClient();\n      const fpr = await getFingerprint();\n      if (!cachedAccountXpub) {\n        cachedAccountXpub = await app.getExtendedPubkey(`m/${accountPath}`);\n      }\n      const { DefaultWalletPolicy } = await import(\"ledger-bitcoin\");\n      const policy = new DefaultWalletPolicy(template, `[${fpr}/${accountPath}]${cachedAccountXpub}`);\n      return { app, fpr, policy, xpub: cachedAccountXpub };\n    }\n\n    async function getLeafPubkey() {\n      if (!cachedLeafPubkey) {\n        const { xpub } = await buildPolicy();\n        const accountKey = HDKey.fromExtendedKey(xpub);\n        const leaf = accountKey.derive(`m/${change}/${addressIndex}`);\n        if (!leaf.publicKey) {\n          throw new SwapKitError(\"wallet_ledger_get_address_error\", {\n            message: `Cannot derive leaf pubkey for ${chain}`,\n          });\n        }\n        cachedLeafPubkey = leaf.publicKey;\n      }\n      return cachedLeafPubkey;\n    }\n\n    return {\n      connect: async () => {\n        await getAppClient();\n      },\n      getAddress: async () => {\n        const { app, policy } = await buildPolicy();\n        const address = await app.getWalletAddress(policy, null, change, addressIndex, false);\n        if (!address) {\n          throw new SwapKitError(\"wallet_ledger_get_address_error\", {\n            message: `Cannot get ${chain} address from ledger derivation path: ${derivationPath}`,\n          });\n        }\n        return address;\n      },\n      getExtendedPublicKey: async (path = `m/${accountPath}`) => {\n        const app = await getAppClient();\n        return app.getExtendedPubkey(`m/${normalizeLedgerPath(path)}`);\n      },\n      getPublicKey: getLeafPubkey,\n      signTransaction: async (tx: Transaction): Promise<Transaction> => {\n        const { app, policy, fpr } = await buildPolicy();\n        const fingerprintBE = Number.parseInt(fpr, 16) >>> 0;\n        const pathNumbers = pathToNumberArray(derivationPath);\n        const missingDerivationIndexes = Array.from({ length: tx.inputsLength }, (_, inputIndex) => inputIndex).filter(\n          (inputIndex) => !hasBip32Derivation(tx, inputIndex),\n        );\n\n        if (missingDerivationIndexes.length > 0) {\n          const leafPubkey = await getLeafPubkey();\n\n          // Fallback for PSBTs that do not include per-input HD key origins.\n          for (const inputIndex of missingDerivationIndexes) {\n            tx.updateInput(inputIndex, {\n              bip32Derivation: [[leafPubkey, { fingerprint: fingerprintBE, path: pathNumbers }]],\n            });\n          }\n        }\n\n        if (format === \"legacy\") {\n          dropWitnessUtxoFromLegacyInputs(tx);\n        }\n\n        if (format === \"p2sh\") {\n          await applyMissingSpendingMetadata({\n            chain: UTXO_CHAIN_FOR_COIN[chain],\n            publicKey: await getLeafPubkey(),\n            tx,\n          });\n        }\n\n        const psbtB64 = base64.encode(tx.toPSBT(0));\n        const sigs = await app.signPsbt(psbtB64, policy, null);\n\n        for (const [idx, partial] of sigs) {\n          tx.updateInput(idx, { partialSig: [[new Uint8Array(partial.pubkey), new Uint8Array(partial.signature)]] });\n        }\n\n        return tx;\n      },\n    };\n  };\n};\n\nexport const BitcoinPsbtLedger = BaseLedgerPsbtUTXO({ chain: \"bitcoin\" });\nexport const LitecoinPsbtLedger = BaseLedgerPsbtUTXO({ chain: \"litecoin\" });\n"
-  ],
-  "mappings": "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",
-  "debugId": "196AC9353D4ED98464756E2164756E21",
-  "names": []
-}

package/dist/chunk-83g13ck6.js

@@ -1,5 +0,0 @@
-import{e as M}from"./chunk-1jpcb30j.js";import{SwapKitError as F}from"@swapkit/helpers";var Q=()=>navigator?.usb,$=async()=>{let j=Q();if(typeof j?.getDevices!=="function")return{};let{ledgerUSBVendorId:z}=await import("@ledgerhq/devices"),G=(await j?.getDevices()).filter((P)=>P.vendorId===z);if(G.length>0)return G[0];return j?.requestDevice({filters:[{vendorId:z}]})},B=async()=>{let j=await $();if(!j)throw new F("wallet_ledger_device_not_found");if(j.opened||await j.open(),j.configuration===null)await j.selectConfiguration(1);try{await j.reset()}catch{}let z=j.configuration??j.configurations?.[0],y=z?.interfaces.find(({alternates:m})=>m.some(({interfaceClass:J})=>J===255))||z?.interfaces.find(({alternates:m})=>m.some(({interfaceClass:J})=>J===3));if(!y)throw await j.close(),new F("wallet_ledger_connection_error");let G=y.alternates?.find(({interfaceClass:m})=>m===3)?.interfaceClass,P=y.alternates?.find(({interfaceClass:m})=>m===255)?.interfaceClass;if(G&&!P){let m=(await import("@ledgerhq/hw-transport-webhid")).default;if(!await m.isSupported())throw await j.close(),new F("wallet_ledger_webhid_not_supported");return await m.create()}try{await j.claimInterface(y.interfaceNumber)}catch(m){throw await j.close(),new F("wallet_ledger_connection_claimed",m)}let X=(await import("@ledgerhq/hw-transport-webusb")).default;if(!await X.isSupported())throw new F("wallet_ledger_webusb_not_supported");let{DisconnectedDevice:_}=await import("@ledgerhq/errors"),Y=new X(j,y.interfaceNumber),Z=(m)=>{if(j===m.device)Q()?.removeEventListener("disconnect",Z),Y._emitDisconnect(new _)};return Q()?.addEventListener("disconnect",Z),Y};
-export{B as c};
-
-//# debugId=019B41E14551343964756E2164756E21
-//# sourceMappingURL=chunk-83g13ck6.js.map

package/dist/chunk-83g13ck6.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/ledger/helpers/getLedgerTransport.ts"],
-  "sourcesContent": [
-    "import type Transport from \"@ledgerhq/hw-transport\";\nimport { SwapKitError } from \"@swapkit/helpers\";\n\nconst getNavigatorUsb = () =>\n  navigator?.usb as unknown as {\n    getDevices: () => Promise<any[]>;\n    requestDevice: (requestObject: any) => Promise<any>;\n    removeEventListener: (event: string, callback: (e: any) => void) => void;\n    addEventListener: (event: string, callback: (e: any) => void) => void;\n  };\n\nconst getLedgerDevices = async (): Promise<USBDevice> => {\n  const navigatorUsb = getNavigatorUsb();\n\n  if (typeof navigatorUsb?.getDevices !== \"function\") return {} as USBDevice;\n  const { ledgerUSBVendorId } = await import(\"@ledgerhq/devices\");\n\n  const devices = await navigatorUsb?.getDevices();\n  const existingDevices = devices.filter((d) => d.vendorId === ledgerUSBVendorId);\n  if (existingDevices.length > 0) return existingDevices[0];\n\n  return navigatorUsb?.requestDevice({ filters: [{ vendorId: ledgerUSBVendorId }] });\n};\n\nexport const getLedgerTransport = async (): Promise<Transport> => {\n  const device = await getLedgerDevices();\n\n  if (!device) {\n    throw new SwapKitError(\"wallet_ledger_device_not_found\");\n  }\n\n  device.opened || (await device.open());\n  if (device.configuration === null) await device.selectConfiguration(1);\n\n  try {\n    await device.reset();\n  } catch {\n    // reset fails on devices that are already open\n  }\n\n  const configuration = device.configuration ?? device.configurations?.[0];\n\n  const iface =\n    configuration?.interfaces.find(({ alternates }: { alternates: { interfaceClass: number }[] }) =>\n      alternates.some(({ interfaceClass }) => interfaceClass === 0xff),\n    ) ||\n    configuration?.interfaces.find(({ alternates }: { alternates: { interfaceClass: number }[] }) =>\n      alternates.some(({ interfaceClass }) => interfaceClass === 0x03),\n    );\n\n  if (!iface) {\n    await device.close();\n    throw new SwapKitError(\"wallet_ledger_connection_error\");\n  }\n\n  const klass0x03 = (iface.alternates as any[])?.find(\n    ({ interfaceClass }: { interfaceClass: number }) => interfaceClass === 0x03,\n  )?.interfaceClass as number;\n\n  const klass0xff = (iface.alternates as any[])?.find(\n    ({ interfaceClass }: { interfaceClass: number }) => interfaceClass === 0xff,\n  )?.interfaceClass as number;\n\n  if (klass0x03 && !klass0xff) {\n    // -------- HID class (NEAR, ETH, SOL, etc.) -> WebHID transport --------\n    const TransportWebHID = (await import(\"@ledgerhq/hw-transport-webhid\")).default;\n    const supported = await TransportWebHID.isSupported();\n    if (!supported) {\n      await device.close();\n      throw new SwapKitError(\"wallet_ledger_webhid_not_supported\");\n    }\n    const transport = await TransportWebHID.create();\n    return transport;\n  }\n\n  try {\n    await device.claimInterface(iface.interfaceNumber);\n  } catch (error: unknown) {\n    await device.close();\n\n    throw new SwapKitError(\"wallet_ledger_connection_claimed\", error);\n  }\n\n  const Transport = (await import(\"@ledgerhq/hw-transport-webusb\")).default;\n  const isSupported = await Transport.isSupported();\n  if (!isSupported) throw new SwapKitError(\"wallet_ledger_webusb_not_supported\");\n\n  const { DisconnectedDevice } = await import(\"@ledgerhq/errors\");\n\n  const transport = new Transport(device, iface.interfaceNumber);\n\n  const onDisconnect = (e: any) => {\n    if (device === e.device) {\n      getNavigatorUsb()?.removeEventListener(\"disconnect\", onDisconnect);\n\n      transport._emitDisconnect(new DisconnectedDevice());\n    }\n  };\n  getNavigatorUsb()?.addEventListener(\"disconnect\", onDisconnect);\n\n  return transport as Transport;\n};\n"
-  ],
-  "mappings": "wCACA,uBAAS,yBAET,IAAM,EAAkB,IACtB,WAAW,IAOP,EAAmB,SAAgC,CACvD,IAAM,EAAe,EAAgB,EAErC,GAAI,OAAO,GAAc,aAAe,WAAY,MAAO,CAAC,EAC5D,IAAQ,qBAAsB,KAAa,6BAGrC,GADU,MAAM,GAAc,WAAW,GACf,OAAO,CAAC,IAAM,EAAE,WAAa,CAAiB,EAC9E,GAAI,EAAgB,OAAS,EAAG,OAAO,EAAgB,GAEvD,OAAO,GAAc,cAAc,CAAE,QAAS,CAAC,CAAE,SAAU,CAAkB,CAAC,CAAE,CAAC,GAGtE,EAAqB,SAAgC,CAChE,IAAM,EAAS,MAAM,EAAiB,EAEtC,GAAI,CAAC,EACH,MAAM,IAAI,EAAa,gCAAgC,EAIzD,GADA,EAAO,QAAW,MAAM,EAAO,KAAK,EAChC,EAAO,gBAAkB,KAAM,MAAM,EAAO,oBAAoB,CAAC,EAErE,GAAI,CACF,MAAM,EAAO,MAAM,EACnB,KAAM,EAIR,IAAM,EAAgB,EAAO,eAAiB,EAAO,iBAAiB,GAEhE,EACJ,GAAe,WAAW,KAAK,EAAG,gBAChC,EAAW,KAAK,EAAG,oBAAqB,IAAmB,GAAI,CACjE,GACA,GAAe,WAAW,KAAK,EAAG,gBAChC,EAAW,KAAK,EAAG,oBAAqB,IAAmB,CAAI,CACjE,EAEF,GAAI,CAAC,EAEH,MADA,MAAM,EAAO,MAAM,EACb,IAAI,EAAa,gCAAgC,EAGzD,IAAM,EAAa,EAAM,YAAsB,KAC7C,EAAG,oBAAiD,IAAmB,CACzE,GAAG,eAEG,EAAa,EAAM,YAAsB,KAC7C,EAAG,oBAAiD,IAAmB,GACzE,GAAG,eAEH,GAAI,GAAa,CAAC,EAAW,CAE3B,IAAM,GAAmB,KAAa,0CAAkC,QAExE,GAAI,CADc,MAAM,EAAgB,YAAY,EAGlD,MADA,MAAM,EAAO,MAAM,EACb,IAAI,EAAa,oCAAoC,EAG7D,OADkB,MAAM,EAAgB,OAAO,EAIjD,GAAI,CACF,MAAM,EAAO,eAAe,EAAM,eAAe,EACjD,MAAO,EAAgB,CAGvB,MAFA,MAAM,EAAO,MAAM,EAEb,IAAI,EAAa,mCAAoC,CAAK,EAGlE,IAAM,GAAa,KAAa,0CAAkC,QAElE,GAAI,CADgB,MAAM,EAAU,YAAY,EAC9B,MAAM,IAAI,EAAa,oCAAoC,EAE7E,IAAQ,sBAAuB,KAAa,4BAEtC,EAAY,IAAI,EAAU,EAAQ,EAAM,eAAe,EAEvD,EAAe,CAAC,IAAW,CAC/B,GAAI,IAAW,EAAE,OACf,EAAgB,GAAG,oBAAoB,aAAc,CAAY,EAEjE,EAAU,gBAAgB,IAAI,CAAoB,GAKtD,OAFA,EAAgB,GAAG,iBAAiB,aAAc,CAAY,EAEvD",
-  "debugId": "019B41E14551343964756E2164756E21",
-  "names": []
-}

package/dist/chunk-h2r568rz.js

@@ -1,4 +0,0 @@
-import{e as M}from"./chunk-1jpcb30j.js";import{hex as N}from"@scure/base";import{SwapKitError as Y}from"@swapkit/helpers";async function Z(q,z){let{RawTx:B}=await import("@swapkit/utxo-signer"),{getUtxoApi:D}=await import("@swapkit/toolboxes/utxo"),G=[];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 J=N.encode(f.txid),O=f.nonWitnessUtxo?N.encode(B.encode(f.nonWitnessUtxo)):await D(z).getRawTx(J);if(!O)throw new Y("wallet_ledger_invalid_params",{chain:z,inputIndex:j,reason:"Unable to resolve previous transaction hex for Ledger signing",txid:J});let Q=f.witnessUtxo?{script:f.witnessUtxo.script,value:Number(f.witnessUtxo.amount)}:void 0,V=f.index!==void 0?f.nonWitnessUtxo?.outputs?.[f.index]:void 0,X=Q?.value??(V?Number(V.amount):0);G.push({hash:J,index:f.index,txHex:O,value:X,witnessUtxo:Q})}return G}async function _({legacyClient:q,chain:z,tx:B}){let D=await Z(B,z);return q.signTransaction(B,D)}function E({legacyClient:q,chain:z,address:B}){return{getAddress:async()=>B,signTransaction:async(D)=>{let G=await _({chain:z,legacyClient:q,tx:D}),{Transaction:j}=await import("@swapkit/utxo-signer");return j.fromRaw(N.decode(G))}}}export{_ as signLegacyPsbtTransaction,Z as extractInputsFromPsbt,E as createLegacyPsbtSigner};
-
-//# debugId=86FA7B33FF0F340E64756E2164756E21
-//# sourceMappingURL=chunk-h2r568rz.js.map