@swapkit/wallet-hardware 5.0.0 → 6.0.0

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

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

package/src/ledger/cosmosTypes.ts

@@ -1,98 +0,0 @@
-import { SwapKitError } from "@swapkit/helpers";
-
-export interface Coin {
-  readonly denom: string;
-  readonly amount: string;
-}
-
-export interface EncodeObject {
-  readonly typeUrl: string;
-  readonly value: any;
-}
-
-export interface AminoMsg {
-  readonly type: string;
-  readonly value: any;
-}
-
-export interface AminoMsgSend extends AminoMsg {
-  readonly type: "cosmos-sdk/MsgSend";
-  readonly value: {
-    /** Bech32 account address */
-    readonly from_address: string;
-    /** Bech32 account address */
-    readonly to_address: string;
-    readonly amount: readonly Coin[];
-  };
-}
-
-export interface AminoConverter {
-  readonly aminoType: string;
-  readonly toAmino: (value: any) => any;
-  readonly fromAmino: (value: any) => any;
-}
-
-/** A map from protobuf type URL to the AminoConverter implementation if supported on chain */
-export type AminoConverters = Record<string, AminoConverter | "not_supported_by_chain">;
-
-function isAminoConverter(
-  converter: [string, AminoConverter | "not_supported_by_chain"],
-): converter is [string, AminoConverter] {
-  return typeof converter[1] !== "string";
-}
-
-/**
- * A map from Stargate message types as used in the messages's `Any` type
- * to Amino types.
- */
-export class AminoTypes {
-  // The map type here ensures uniqueness of the protobuf type URL in the key.
-  // There is no uniqueness guarantee of the Amino type identifier in the type
-  // system or constructor. Instead it's the user's responsibility to ensure
-  // there is no overlap when fromAmino is called.
-  private readonly register: Record<string, AminoConverter | "not_supported_by_chain">;
-
-  constructor(types: AminoConverters) {
-    this.register = types;
-  }
-
-  toAmino({ typeUrl, value }: EncodeObject): AminoMsg {
-    const converter = this.register[typeUrl];
-    if (converter === "not_supported_by_chain") {
-      throw new SwapKitError("wallet_ledger_chain_not_supported", {
-        reason: `The message type '${typeUrl}' cannot be signed using the Amino JSON sign mode because this is not supported by chain.`,
-      });
-    }
-    if (!converter) {
-      throw new SwapKitError("wallet_ledger_invalid_params", {
-        reason: `Type URL '${typeUrl}' does not exist in the Amino message type register.`,
-      });
-    }
-    return { type: converter.aminoType, value: converter.toAmino(value) };
-  }
-
-  fromAmino({ type, value }: AminoMsg): EncodeObject {
-    const matches = Object.entries(this.register)
-      .filter(isAminoConverter)
-      .filter(([_typeUrl, { aminoType }]) => aminoType === type);
-
-    if (matches.length === 0) {
-      throw new SwapKitError("wallet_ledger_invalid_params", {
-        reason: `Amino type identifier '${type}' does not exist in the Amino message type register.`,
-      });
-    }
-
-    if (matches.length > 1) {
-      throw new SwapKitError("wallet_ledger_invalid_params", {
-        reason: `Multiple types are registered with Amino type identifier '${type}': '${matches
-          .map(([key, _value]) => key)
-          .sort()
-          .join("', '")}'. Thus fromAmino cannot be performed.`,
-      });
-    }
-
-    const [typeUrl, converter] = matches[0] as [string, AminoConverter];
-
-    return { typeUrl, value: converter.fromAmino(value) };
-  }
-}

package/src/ledger/helpers/getLedgerTransport.ts

@@ -1,102 +0,0 @@
-import type Transport from "@ledgerhq/hw-transport";
-import { SwapKitError } from "@swapkit/helpers";
-
-const getNavigatorUsb = () =>
-  navigator?.usb as unknown as {
-    getDevices: () => Promise<any[]>;
-    requestDevice: (requestObject: any) => Promise<any>;
-    removeEventListener: (event: string, callback: (e: any) => void) => void;
-    addEventListener: (event: string, callback: (e: any) => void) => void;
-  };
-
-const getLedgerDevices = async (): Promise<USBDevice> => {
-  const navigatorUsb = getNavigatorUsb();
-
-  if (typeof navigatorUsb?.getDevices !== "function") return {} as USBDevice;
-  const { ledgerUSBVendorId } = await import("@ledgerhq/devices");
-
-  const devices = await navigatorUsb?.getDevices();
-  const existingDevices = devices.filter((d) => d.vendorId === ledgerUSBVendorId);
-  if (existingDevices.length > 0) return existingDevices[0];
-
-  return navigatorUsb?.requestDevice({ filters: [{ vendorId: ledgerUSBVendorId }] });
-};
-
-export const getLedgerTransport = async (): Promise<Transport> => {
-  const device = await getLedgerDevices();
-
-  if (!device) {
-    throw new SwapKitError("wallet_ledger_device_not_found");
-  }
-
-  device.opened || (await device.open());
-  if (device.configuration === null) await device.selectConfiguration(1);
-
-  try {
-    await device.reset();
-  } catch {
-    // reset fails on devices that are already open
-  }
-
-  const configuration = device.configuration ?? device.configurations?.[0];
-
-  const iface =
-    configuration?.interfaces.find(({ alternates }: { alternates: { interfaceClass: number }[] }) =>
-      alternates.some(({ interfaceClass }) => interfaceClass === 0xff),
-    ) ||
-    configuration?.interfaces.find(({ alternates }: { alternates: { interfaceClass: number }[] }) =>
-      alternates.some(({ interfaceClass }) => interfaceClass === 0x03),
-    );
-
-  if (!iface) {
-    await device.close();
-    throw new SwapKitError("wallet_ledger_connection_error");
-  }
-
-  const klass0x03 = (iface.alternates as any[])?.find(
-    ({ interfaceClass }: { interfaceClass: number }) => interfaceClass === 0x03,
-  )?.interfaceClass as number;
-
-  const klass0xff = (iface.alternates as any[])?.find(
-    ({ interfaceClass }: { interfaceClass: number }) => interfaceClass === 0xff,
-  )?.interfaceClass as number;
-
-  if (klass0x03 && !klass0xff) {
-    // -------- HID class (NEAR, ETH, SOL, etc.) -> WebHID transport --------
-    const TransportWebHID = (await import("@ledgerhq/hw-transport-webhid")).default;
-    const supported = await TransportWebHID.isSupported();
-    if (!supported) {
-      await device.close();
-      throw new SwapKitError("wallet_ledger_webhid_not_supported");
-    }
-    const transport = await TransportWebHID.create();
-    return transport;
-  }
-
-  try {
-    await device.claimInterface(iface.interfaceNumber);
-  } catch (error: unknown) {
-    await device.close();
-
-    throw new SwapKitError("wallet_ledger_connection_claimed", error);
-  }
-
-  const Transport = (await import("@ledgerhq/hw-transport-webusb")).default;
-  const isSupported = await Transport.isSupported();
-  if (!isSupported) throw new SwapKitError("wallet_ledger_webusb_not_supported");
-
-  const { DisconnectedDevice } = await import("@ledgerhq/errors");
-
-  const transport = new Transport(device, iface.interfaceNumber);
-
-  const onDisconnect = (e: any) => {
-    if (device === e.device) {
-      getNavigatorUsb()?.removeEventListener("disconnect", onDisconnect);
-
-      transport._emitDisconnect(new DisconnectedDevice());
-    }
-  };
-  getNavigatorUsb()?.addEventListener("disconnect", onDisconnect);
-
-  return transport as Transport;
-};

package/src/ledger/helpers/ledgerNetworkInfo.ts

@@ -1,127 +0,0 @@
-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/interfaces/CosmosLedgerInterface.ts

@@ -1,67 +0,0 @@
-import type Transport from "@ledgerhq/hw-transport";
-import { type DerivationPathArray, LedgerErrorCode, NetworkDerivationPath, SwapKitError } from "@swapkit/helpers";
-
-import { THORChainApp } from "../clients/thorchain/lib";
-import { getLedgerTransport } from "../helpers/getLedgerTransport";
-
-export abstract class CosmosLedgerInterface {
-  ledgerTimeout = 50000;
-  derivationPath: DerivationPathArray | string = NetworkDerivationPath.GAIA;
-  transport: any;
-  ledgerApp: any;
-  chain: "thor" | "cosmos" = "thor";
-
-  private readonly injectedTransport?: Transport;
-
-  constructor(transport?: Transport) {
-    this.injectedTransport = transport;
-    if (transport) this.transport = transport;
-  }
-
-  checkOrCreateTransportAndLedger = async (forceReconnect = false) => {
-    if (!forceReconnect && this.transport && this.ledgerApp) return;
-
-    try {
-      // Consumer owns the lifecycle of an injected transport, so forceReconnect
-      // only refreshes ledgerApp — the transport itself stays as passed in.
-      const needsNewTransport = !this.transport || (forceReconnect && !this.injectedTransport);
-      if (needsNewTransport) {
-        this.transport = this.injectedTransport ?? (await getLedgerTransport());
-      }
-
-      switch (this.chain) {
-        case "thor": {
-          this.ledgerApp = forceReconnect || !this.ledgerApp ? new THORChainApp(this.transport) : this.ledgerApp;
-
-          break;
-        }
-
-        case "cosmos": {
-          const CosmosApp = (await import("@ledgerhq/hw-app-cosmos")).default;
-          this.ledgerApp = forceReconnect || !this.ledgerApp ? new CosmosApp(this.transport) : this.ledgerApp;
-        }
-      }
-
-      return this.ledgerApp;
-    } catch (error: unknown) {
-      throw new SwapKitError("wallet_ledger_connection_error", error);
-    }
-  };
-
-  validateResponse = (errorCode: LedgerErrorCode, message?: string) => {
-    switch (errorCode) {
-      case LedgerErrorCode.NoError:
-        return;
-
-      case LedgerErrorCode.LockedDevice:
-        throw new SwapKitError("wallet_ledger_device_locked", { message: `Ledger is locked: ${message}` });
-
-      case LedgerErrorCode.TC_NotFound:
-        throw new SwapKitError("wallet_ledger_device_not_found");
-
-      default: {
-        break;
-      }
-    }
-  };
-}