@swapkit/wallet-hardware 4.10.0 → 5.0.0

package/package.json

@@ -9,7 +9,7 @@
     "@ledgerhq/errors": "~6.29.0",
     "@ledgerhq/hw-app-btc": "~10.17.0",
     "@ledgerhq/hw-app-cosmos": "~6.33.0",
-    "@ledgerhq/hw-app-eth": "~7.4.2",
+    "@ledgerhq/hw-app-eth": "~7.8.18",
     "@ledgerhq/hw-app-near": "~6.32.0",
     "@ledgerhq/hw-app-sui": "~1.5.0",
     "@ledgerhq/hw-app-trx": "~6.32.0",
@@ -22,10 +22,10 @@
     "@near-js/transactions": "~2.5.0",
     "@scure/base": "2.2.0",
     "@scure/bip32": "2.2.0",
-    "@swapkit/helpers": "^5.4.1",
-    "@swapkit/toolboxes": "^5.4.1",
+    "@swapkit/helpers": "^6.0.0",
+    "@swapkit/toolboxes": "^6.0.0",
     "@swapkit/utxo-signer": "^3.1.0",
-    "@swapkit/wallet-core": "^5.0.8",
+    "@swapkit/wallet-core": "^5.0.10",
     "@trezor/connect-web": "~9.7.3",
     "cosmjs-types": "~0.10.1",
     "ethers": "^6.14.0",
@@ -44,7 +44,7 @@
     "@ledgerhq/errors": "6.29.0",
     "@ledgerhq/hw-app-btc": "10.17.0",
     "@ledgerhq/hw-app-cosmos": "6.33.0",
-    "@ledgerhq/hw-app-eth": "7.4.2",
+    "@ledgerhq/hw-app-eth": "7.8.18",
     "@ledgerhq/hw-app-near": "6.32.0",
     "@ledgerhq/hw-app-sui": "1.5.0",
     "@ledgerhq/hw-app-trx": "6.32.0",
@@ -109,5 +109,5 @@
     "type-check:go": "tsgo"
   },
   "type": "module",
-  "version": "4.10.0"
+  "version": "5.0.0"
 }

package/src/keepkey/chains/utxo.ts

@@ -8,6 +8,7 @@ import {
   type GenericTransferParams,
   SwapKitError,
   type UTXOChain,
+  UTXOScriptType,
 } from "@swapkit/helpers";
 import {
   assertDerivationIndex,
@@ -44,11 +45,13 @@ export async function utxoWalletMethods({
   derivationPath?: DerivationPathArray;
 }): Promise<KeepKeyUTXOWalletMethods> {
   const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
-  // This might not work for BCH
-  const toolbox = await getUtxoToolbox(chain);
   const scriptType = [Chain.Bitcoin, Chain.Litecoin].includes(chain as typeof Chain.Bitcoin)
     ? ("p2wpkh" as const)
     : ("p2pkh" as const);
+  // This might not work for BCH
+  const toolbox = await getUtxoToolbox(chain, {
+    scriptType: scriptType === "p2wpkh" ? UTXOScriptType.P2WPKH : UTXOScriptType.P2PKH,
+  });
 
   const derivationPathString = derivationPath ? derivationPathToString(derivationPath) : `${DerivationPath[chain]}/0`;
 

package/src/ledger/clients/evm.ts

@@ -16,6 +16,32 @@ import {
 } from "ethers";
 
 import { getLedgerTransport } from "../helpers/getLedgerTransport";
+import {
+  fetchLedgerNetworkCertificate,
+  fetchLedgerNetworkDescriptor,
+  provideLedgerCertificate,
+  provideLedgerNetworkInformation,
+} from "../helpers/ledgerNetworkInfo";
+
+const LEDGER_INCORRECT_DATA = 0x6a80;
+
+const ARC_CHAIN_ID = Number(ChainId.Arc);
+
+type LedgerTransactionResolution = Awaited<
+  ReturnType<typeof import("@ledgerhq/hw-app-eth")["ledgerService"]["resolveTransaction"]>
+>;
+
+function isLedgerIncorrectDataError(error: unknown) {
+  return (
+    error instanceof Error &&
+    "statusCode" in error &&
+    (error as { statusCode: number }).statusCode === LEDGER_INCORRECT_DATA
+  );
+}
+
+function hasClearSigningPayload(resolution: LedgerTransactionResolution | null) {
+  return Object.values(resolution ?? {}).some((entries) => Array.isArray(entries) && entries.length);
+}
 
 function parseLedgerSignatureV(v: number | string) {
   if (typeof v === "number") return v;
@@ -31,6 +57,7 @@ class EVMLedgerInterface extends AbstractSigner {
   ledgerTimeout = 50000;
   private transport?: Transport;
   private readonly injectedTransport?: Transport;
+  private arcNetworkRegistered = false;
 
   constructor({
     provider,
@@ -172,9 +199,22 @@ class EVMLedgerInterface extends AbstractSigner {
 
     const { ledgerService } = await import("@ledgerhq/hw-app-eth");
 
-    const resolution = await ledgerService.resolveTransaction(unsignedTx, {}, { erc20: true, externalPlugins: true });
+    const chainId = Number(baseTx.chainId);
+    const isArc = chainId === ARC_CHAIN_ID;
+
+    const resolution = await ledgerService
+      .resolveTransaction(unsignedTx, {}, { erc20: true, externalPlugins: true })
+      .catch((error) => {
+        if (!isArc) throw error;
+
+        console.warn("Ledger: could not fetch clear-signing metadata for Arc, signing blind");
+
+        return null;
+      });
+
+    if (isArc && !this.arcNetworkRegistered) await this.registerNetworkOnDevice(chainId);
 
-    const signature = await this.ledgerApp?.signTransaction(this.derivationPath, unsignedTx, resolution);
+    const signature = await this.signWithLedgerApp(unsignedTx, resolution, chainId);
 
     if (!signature) throw new SwapKitError("wallet_ledger_signing_error");
 
@@ -183,6 +223,48 @@ class EVMLedgerInterface extends AbstractSigner {
     return Transaction.from({ ...baseTx, signature: { r: `0x${r}`, s: `0x${s}`, v: parseLedgerSignatureV(v) } })
       .serialized;
   };
+
+  private signWithLedgerApp = async (
+    unsignedTx: string,
+    resolution: LedgerTransactionResolution | null,
+    chainId: number,
+  ) => {
+    try {
+      return await this.ledgerApp?.signTransaction(this.derivationPath, unsignedTx, resolution);
+    } catch (error) {
+      const canSignBlind =
+        chainId === ARC_CHAIN_ID && isLedgerIncorrectDataError(error) && hasClearSigningPayload(resolution);
+
+      if (!canSignBlind) throw error;
+
+      console.warn("Ledger: the app rejected the Arc metadata, signing blind");
+
+      return await this.ledgerApp?.signTransaction(this.derivationPath, unsignedTx, null);
+    }
+  };
+
+  private registerNetworkOnDevice = async (chainId: number) => {
+    const deviceModelId = this.transport?.deviceModel?.id;
+
+    if (!(this.transport && deviceModelId)) return;
+
+    try {
+      const [descriptor, certificate] = await Promise.all([
+        fetchLedgerNetworkDescriptor(chainId, deviceModelId),
+        fetchLedgerNetworkCertificate(deviceModelId),
+      ]);
+
+      if (!descriptor) return;
+
+      if (certificate) await provideLedgerCertificate(this.transport, certificate);
+
+      await provideLedgerNetworkInformation(this.transport, descriptor);
+
+      this.arcNetworkRegistered = true;
+    } catch {
+      // the app will reject the metadata and signWithLedgerApp falls back to blind signing
+    }
+  };
 }
 
 type LedgerParams = { provider: Provider; derivationPath?: DerivationPathArray; transport?: Transport };

package/src/ledger/clients/utxo-psbt.ts

@@ -135,6 +135,7 @@ const BaseLedgerPsbtUTXO = ({ chain }: { chain: SupportedCoin }) => {
         const app = await getAppClient();
         return app.getExtendedPubkey(`m/${normalizeLedgerPath(path)}`);
       },
+      getPublicKey: getLeafPubkey,
       signTransaction: async (tx: Transaction): Promise<Transaction> => {
         const { app, policy, fpr } = await buildPolicy();
         const fingerprintBE = Number.parseInt(fpr, 16) >>> 0;

package/src/ledger/helpers/ledgerNetworkInfo.ts

@@ -0,0 +1,127 @@
+import type Transport from "@ledgerhq/hw-transport";
+
+const LEDGER_CAL_SERVICE_URL = "https://crypto-assets-service.api.ledger.com/v1";
+
+const LEDGER_DEVICE_TO_CAL_MODEL: Record<string, string> = {
+  apex: "apexp",
+  europa: "flex",
+  nanoS: "nanos",
+  nanoSP: "nanosp",
+  nanoX: "nanox",
+  stax: "stax",
+};
+
+const APDU_CLA = 0xe0;
+const APDU_CLA_PKI = 0xb0;
+const APDU_INS_LOAD_CERTIFICATE = 0x06;
+const LEDGER_KEY_USAGE_NETWORK = 0x0c;
+const APDU_INS_PROVIDE_NETWORK_INFORMATION = 0x30;
+const APDU_P1_FIRST_CHUNK = 0x01;
+const APDU_P1_FOLLOWING_CHUNK = 0x00;
+const APDU_P2_NETWORK_CONFIG = 0x00;
+const APDU_P2_NETWORK_ICON = 0x01;
+const APDU_MAX_CHUNK_SIZE = 0xff;
+const TLV_TAG_DER_SIGNATURE = 0x15;
+
+export type LedgerNetworkDescriptor = { data: string; icon?: string; signature: string };
+
+type CalNetwork = {
+  chain_id: number;
+  descriptors?: Record<string, { data?: string; signatures?: { prod?: string } }>;
+  icons?: Record<string, string>;
+};
+
+export async function fetchLedgerNetworkCertificate(
+  deviceModelId: string,
+  fetchFn: typeof fetch = fetch,
+): Promise<string | null> {
+  const calModel = LEDGER_DEVICE_TO_CAL_MODEL[deviceModelId];
+  if (!calModel) return null;
+
+  const url = `${LEDGER_CAL_SERVICE_URL}/certificates?output=descriptor&public_key_usage=network&target_device=${calModel}`;
+  const response = await fetchFn(url);
+  if (!response.ok) return null;
+
+  const certificates = (await response.json()) as Array<{
+    descriptor?: { data?: string; signatures?: { prod?: string } };
+  }>;
+  const descriptor = certificates[0]?.descriptor;
+  const signature = descriptor?.signatures?.prod;
+
+  if (!(descriptor?.data && signature)) return null;
+
+  return `${descriptor.data}${appendSignatureTlv(signature)}`;
+}
+
+export async function provideLedgerCertificate(transport: Transport, payloadHex: string) {
+  await transport.send(
+    APDU_CLA_PKI,
+    APDU_INS_LOAD_CERTIFICATE,
+    LEDGER_KEY_USAGE_NETWORK,
+    0x00,
+    Buffer.from(payloadHex, "hex"),
+  );
+}
+
+export async function fetchLedgerNetworkDescriptor(
+  chainId: number,
+  deviceModelId: string,
+  fetchFn: typeof fetch = fetch,
+): Promise<LedgerNetworkDescriptor | null> {
+  const calModel = LEDGER_DEVICE_TO_CAL_MODEL[deviceModelId];
+  if (!calModel) return null;
+
+  const url = `${LEDGER_CAL_SERVICE_URL}/networks?chain_id=${chainId}&output=chain_id,descriptors,icons`;
+  const response = await fetchFn(url);
+  if (!response.ok) return null;
+
+  const networks = (await response.json()) as CalNetwork[];
+  const network = networks.find((entry) => entry.chain_id === chainId);
+  const descriptor = network?.descriptors?.[calModel];
+  const signature = descriptor?.signatures?.prod;
+
+  if (!(descriptor?.data && signature)) return null;
+
+  return { data: descriptor.data, icon: network?.icons?.[calModel], signature };
+}
+
+function appendSignatureTlv(signature: string) {
+  return encodeTlv(TLV_TAG_DER_SIGNATURE, Buffer.from(signature, "hex")).toString("hex");
+}
+
+function encodeTlv(tag: number, value: Buffer) {
+  return Buffer.concat([Buffer.from([tag, value.length]), value]);
+}
+
+export function encodeNetworkInfoPayload({ data, signature }: LedgerNetworkDescriptor) {
+  const tlv = Buffer.concat([
+    Buffer.from(data, "hex"),
+    encodeTlv(TLV_TAG_DER_SIGNATURE, Buffer.from(signature, "hex")),
+  ]);
+  const length = Buffer.alloc(2);
+  length.writeUInt16BE(tlv.length, 0);
+  return Buffer.concat([length, tlv]);
+}
+
+async function sendChunked(transport: Transport, p2: number, payload: Buffer) {
+  for (let offset = 0; offset < payload.length; offset += APDU_MAX_CHUNK_SIZE) {
+    const p1 = offset === 0 ? APDU_P1_FIRST_CHUNK : APDU_P1_FOLLOWING_CHUNK;
+    const chunk = payload.subarray(offset, offset + APDU_MAX_CHUNK_SIZE);
+    await transport.send(APDU_CLA, APDU_INS_PROVIDE_NETWORK_INFORMATION, p1, p2, chunk);
+  }
+}
+
+export async function provideLedgerNetworkInformation(transport: Transport, descriptor: LedgerNetworkDescriptor) {
+  const payload = encodeNetworkInfoPayload(descriptor);
+  await sendChunked(transport, APDU_P2_NETWORK_CONFIG, payload);
+
+  if (!descriptor.icon) return { iconAccepted: false };
+
+  try {
+    await sendChunked(transport, APDU_P2_NETWORK_ICON, Buffer.from(descriptor.icon, "hex"));
+    return { iconAccepted: true };
+  } catch {
+    await sendChunked(transport, APDU_P2_NETWORK_CONFIG, payload);
+    return { iconAccepted: false };
+  }
+}

package/src/ledger/index.ts

@@ -11,6 +11,7 @@ import {
   NetworkDerivationPath,
   SwapKitError,
   type UTXOChain,
+  UTXOScriptType,
   WalletOption,
 } from "@swapkit/helpers";
 import {
@@ -19,6 +20,7 @@ import {
   compileMemo,
   createHDWalletHelpers,
   getNetworkForChain,
+  getScriptTypeForAddress,
   getUTXOAccountIndexFromPath,
   getUTXOAccountPath,
   getUTXOAddressPath,
@@ -172,6 +174,7 @@ async function getWalletMethods({
       const signer = await getLedgerClient({ chain, derivationPath, transport });
 
       const address = providedAddress ?? (await getLedgerAddress({ chain, ledgerClient: signer }));
+      const scriptType = getScriptTypeForAddress(address, utxoChain);
 
       // V3 toolbox signer:
       //  - BTC uses the modern `ledger-bitcoin` AppClient with native PSBT signing.
@@ -181,13 +184,19 @@ async function getWalletMethods({
       //    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> }
+        | {
+            getAddress: () => Promise<string>;
+            publicKey?: Uint8Array;
+            signTransaction: (tx: Transaction) => Promise<Transaction>;
+          }
         | undefined;
+      let publicKey: Uint8Array | undefined;
       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 };
+        publicKey = scriptType === UTXOScriptType.P2SH_P2WPKH ? await psbtClient.getPublicKey() : undefined;
+        toolboxSigner = { getAddress: psbtClient.getAddress, publicKey, signTransaction: psbtClient.signTransaction };
       } else if (
         chain === Chain.BitcoinCash ||
         chain === Chain.Dogecoin ||
@@ -203,8 +212,8 @@ async function getWalletMethods({
       }
 
       const toolbox = toolboxSigner
-        ? await getUtxoToolbox(utxoChain, { signer: toolboxSigner })
-        : getUtxoToolbox(utxoChain);
+        ? await getUtxoToolbox(utxoChain, { scriptType, signer: toolboxSigner })
+        : getUtxoToolbox(utxoChain, { scriptType });
       const signAndBroadcastTransaction = signAndBroadcastLegacyPsbtTransaction ?? toolbox.signAndBroadcastTransaction;
 
       const transfer = async (params: UTXOBuildTxParams) => {
@@ -216,6 +225,7 @@ async function getWalletMethods({
           feeRate,
           fetchTxHex: true,
           memo,
+          publicKey: params.publicKey ?? publicKey,
           sender: address,
         });
 

package/src/trezor/evmSigner.ts

@@ -123,14 +123,13 @@ export async function getEVMSigner({ chain, derivationPath, provider }: TrezorEV
       if (!to) throw new SwapKitError({ errorKey: "wallet_missing_params", info: { to } });
       if (!gasLimit) throw new SwapKitError({ errorKey: "wallet_missing_params", info: { gasLimit } });
 
-      const isEIP1559 = maxFeePerGas && maxPriorityFeePerGas;
+      // Check presence, not truthiness: a zero-wei tip is legitimate on chains with a negligible
+      // priority fee, such as Arc, where it used to be read as missing fee data.
+      const isEIP1559 = maxFeePerGas != null || maxPriorityFeePerGas != null;
 
       if (isEIP1559 && !maxFeePerGas) {
         throw new SwapKitError({ errorKey: "wallet_missing_params", info: { maxFeePerGas } });
       }
-      if (isEIP1559 && !maxPriorityFeePerGas) {
-        throw new SwapKitError({ errorKey: "wallet_missing_params", info: { maxPriorityFeePerGas } });
-      }
       if (!(isEIP1559 || gasPrice)) {
         throw new SwapKitError({ errorKey: "wallet_missing_params", info: { gasPrice } });
       }

package/src/trezor/index.ts

@@ -10,6 +10,7 @@ import {
   SKConfig,
   SwapKitError,
   type UTXOChain,
+  UTXOScriptType,
   WalletOption,
 } from "@swapkit/helpers";
 import {
@@ -208,11 +209,11 @@ function decodeOpReturnData(script: Uint8Array): string | null {
 function getScriptType(derivationPath: DerivationPathArray) {
   switch (derivationPath[0]) {
     case 84:
-      return { input: "SPENDWITNESS", output: "PAYTOWITNESS" } as const;
+      return { input: "SPENDWITNESS", output: "PAYTOWITNESS", utxo: UTXOScriptType.P2WPKH } as const;
     case 49:
-      return { input: "SPENDP2SHWITNESS", output: "PAYTOP2SHWITNESS" } as const;
+      return { input: "SPENDP2SHWITNESS", output: "PAYTOP2SHWITNESS", utxo: UTXOScriptType.P2SH_P2WPKH } as const;
     case 44:
-      return { input: "SPENDADDRESS", output: "PAYTOADDRESS" } as const;
+      return { input: "SPENDADDRESS", output: "PAYTOADDRESS", utxo: UTXOScriptType.P2PKH } as const;
     default:
       return null;
   }
@@ -498,6 +499,7 @@ async function getTrezorWallet<T extends Chain>({
 }) {
   switch (chain) {
     case Chain.Arbitrum:
+    case Chain.Arc:
     case Chain.Aurora:
     case Chain.Avalanche:
     case Chain.Base:
@@ -689,6 +691,7 @@ async function getTrezorWallet<T extends Chain>({
       }
 
       const resolvedScriptType = scriptType;
+      const toolboxParams = { scriptType: scriptType.utxo };
       const coin = chain.toLowerCase();
 
       const getAddress = async (path: DerivationPathArray = derivationPath) => {
@@ -716,7 +719,7 @@ async function getTrezorWallet<T extends Chain>({
       };
 
       const address = providedAddress ?? (await getAddress());
-      const baseToolbox = getUtxoToolbox(chain);
+      const baseToolbox = getUtxoToolbox(chain, toolboxParams);
 
       const signTransaction = async (tx: Transaction, inputs: UTXOType[], memo = "") => {
         const TrezorConnect = (await import("@trezor/connect-web")).default;
@@ -997,7 +1000,7 @@ async function getTrezorWallet<T extends Chain>({
         feeRate?: number;
         feeOptionKey?: (typeof FeeOption)[keyof typeof FeeOption];
       }) => {
-        const toolbox = getUtxoToolbox(chain);
+        const toolbox = getUtxoToolbox(chain, toolboxParams);
         const txFeeRate = feeRate || (await toolbox.getFeeRates())[feeOptionKey || FeeOption.Fast];
 
         const { tx, inputs: selectedInputs } = await toolbox.createTransaction({
@@ -1037,7 +1040,7 @@ async function getTrezorWallet<T extends Chain>({
           });
         }
 
-        const toolbox = getUtxoToolbox(chain);
+        const toolbox = getUtxoToolbox(chain, toolboxParams);
 
         const feeRate = paramFeeRate || (await toolbox.getFeeRates())[feeOptionKey || FeeOption.Fast];
 
@@ -1060,6 +1063,7 @@ async function getTrezorWallet<T extends Chain>({
 
       const toolbox = shouldUseTrezorPsbtSigner(chain)
         ? await getUtxoToolbox(utxoChain, {
+            ...toolboxParams,
             signer: { getAddress: async () => address, signTransaction: signPsbtTransaction },
           })
         : baseToolbox;
@@ -1358,6 +1362,7 @@ export const trezorWallet = createWallet({
     },
   directSigningSupport: {
     [Chain.Arbitrum]: true,
+    [Chain.Arc]: true,
     [Chain.Aurora]: true,
     [Chain.Avalanche]: true,
     [Chain.Base]: true,
@@ -1380,6 +1385,7 @@ export const trezorWallet = createWallet({
   name: "connectTrezor",
   supportedChains: [
     Chain.Arbitrum,
+    Chain.Arc,
     Chain.Aurora,
     Chain.Avalanche,
     Chain.Base,

package/dist/chunk-gwx23jdp.js

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

package/dist/chunk-qs60k0yv.js

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