@swapkit/wallet-hardware 5.0.1 → 6.0.1

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;
-      }
-    }
-  };
-}