@swapkit/wallet-hardware 4.8.1 → 4.8.2

package/src/ledger/helpers/getLedgerClient.ts

@@ -0,0 +1,124 @@
+import { Chain, type DerivationPathArray, type EVMChain, SwapKitError, WalletOption } from "@swapkit/helpers";
+
+import { CosmosLedger } from "../clients/cosmos";
+import {
+  ArbitrumLedger,
+  AuroraLedger,
+  AvalancheLedger,
+  BaseLedger,
+  BerachainLedger,
+  BinanceSmartChainLedger,
+  EthereumLedger,
+  GnosisLedger,
+  MonadLedger,
+  OptimismLedger,
+  PolygonLedger,
+  XLayerLedger,
+} from "../clients/evm";
+import { getNearLedgerClient } from "../clients/near";
+import { SuiLedger } from "../clients/sui";
+import { THORChainLedger } from "../clients/thorchain";
+import { TronLedger } from "../clients/tron";
+import {
+  BitcoinCashLedger,
+  BitcoinLedger,
+  DashLedger,
+  DogecoinLedger,
+  LitecoinLedger,
+  ZcashLedger,
+} from "../clients/utxo";
+import { XRPLedger } from "../clients/xrp";
+
+type LedgerSignerMap = {
+  [Chain.Arbitrum]: ReturnType<typeof ArbitrumLedger>;
+  [Chain.Aurora]: ReturnType<typeof AuroraLedger>;
+  [Chain.Avalanche]: ReturnType<typeof AvalancheLedger>;
+  [Chain.Base]: ReturnType<typeof BaseLedger>;
+  [Chain.Berachain]: ReturnType<typeof BerachainLedger>;
+  [Chain.BinanceSmartChain]: ReturnType<typeof BinanceSmartChainLedger>;
+  [Chain.BitcoinCash]: ReturnType<typeof BitcoinCashLedger>;
+  [Chain.Bitcoin]: ReturnType<typeof BitcoinLedger>;
+  [Chain.Cosmos]: CosmosLedger;
+  [Chain.Dash]: ReturnType<typeof DashLedger>;
+  [Chain.Dogecoin]: ReturnType<typeof DogecoinLedger>;
+  [Chain.Ethereum]: ReturnType<typeof EthereumLedger>;
+  [Chain.Gnosis]: ReturnType<typeof GnosisLedger>;
+  [Chain.Litecoin]: ReturnType<typeof LitecoinLedger>;
+  [Chain.Monad]: ReturnType<typeof MonadLedger>;
+  [Chain.Near]: ReturnType<typeof getNearLedgerClient>;
+  [Chain.Optimism]: ReturnType<typeof OptimismLedger>;
+  [Chain.Polygon]: ReturnType<typeof PolygonLedger>;
+  [Chain.Ripple]: ReturnType<typeof XRPLedger>;
+  [Chain.Sui]: ReturnType<typeof SuiLedger>;
+  [Chain.THORChain]: THORChainLedger;
+  [Chain.Tron]: ReturnType<typeof TronLedger>;
+  [Chain.XLayer]: ReturnType<typeof XLayerLedger>;
+  [Chain.Zcash]: ReturnType<typeof ZcashLedger>;
+};
+
+type LedgerSupportedChain = keyof LedgerSignerMap;
+
+export const getLedgerClient = async <T extends LedgerSupportedChain>({
+  chain,
+  derivationPath,
+}: {
+  chain: T;
+  derivationPath?: DerivationPathArray;
+}): Promise<LedgerSignerMap[T]> => {
+  const { match } = await import("ts-pattern");
+
+  return (
+    match(chain as LedgerSupportedChain)
+      .returnType<Promise<LedgerSignerMap[T]>>()
+      .with(Chain.THORChain, () => Promise.resolve(new THORChainLedger(derivationPath) as LedgerSignerMap[T]))
+      .with(Chain.Cosmos, () => Promise.resolve(new CosmosLedger(derivationPath) as LedgerSignerMap[T]))
+      .with(Chain.Bitcoin, () => Promise.resolve(BitcoinLedger(derivationPath) as LedgerSignerMap[T]))
+      .with(Chain.BitcoinCash, () => Promise.resolve(BitcoinCashLedger(derivationPath) as LedgerSignerMap[T]))
+      .with(Chain.Dash, () => Promise.resolve(DashLedger(derivationPath) as LedgerSignerMap[T]))
+      .with(Chain.Dogecoin, () => Promise.resolve(DogecoinLedger(derivationPath) as LedgerSignerMap[T]))
+      .with(Chain.Litecoin, () => Promise.resolve(LitecoinLedger(derivationPath) as LedgerSignerMap[T]))
+      .with(Chain.Zcash, () => Promise.resolve(ZcashLedger(derivationPath) as LedgerSignerMap[T]))
+      .with(Chain.Ripple, () => Promise.resolve(XRPLedger(derivationPath) as LedgerSignerMap[T]))
+      .with(Chain.Tron, () => Promise.resolve(TronLedger(derivationPath) as LedgerSignerMap[T]))
+      .with(Chain.Sui, () => Promise.resolve(SuiLedger(derivationPath) as LedgerSignerMap[T]))
+      // @ts-expect-error
+      .with(Chain.Near, () => {
+        return Promise.resolve(getNearLedgerClient(derivationPath));
+      })
+      .with(
+        Chain.Arbitrum,
+        Chain.Aurora,
+        Chain.Avalanche,
+        Chain.Berachain,
+        Chain.BinanceSmartChain,
+        Chain.Ethereum,
+        Chain.Gnosis,
+        Chain.Monad,
+        Chain.Optimism,
+        Chain.Polygon,
+        Chain.Base,
+        Chain.XLayer,
+        async () => {
+          const { getProvider } = await import("@swapkit/toolboxes/evm");
+          const params = { derivationPath, provider: await getProvider(chain as EVMChain) };
+
+          return match(chain as Chain)
+            .with(Chain.BinanceSmartChain, () => BinanceSmartChainLedger(params) as LedgerSignerMap[T])
+            .with(Chain.Avalanche, () => AvalancheLedger(params) as LedgerSignerMap[T])
+            .with(Chain.Arbitrum, () => ArbitrumLedger(params) as LedgerSignerMap[T])
+            .with(Chain.Berachain, () => BerachainLedger(params) as LedgerSignerMap[T])
+            .with(Chain.Optimism, () => OptimismLedger(params) as LedgerSignerMap[T])
+            .with(Chain.Polygon, () => PolygonLedger(params) as LedgerSignerMap[T])
+            .with(Chain.Base, () => BaseLedger(params) as LedgerSignerMap[T])
+            .with(Chain.Aurora, () => AuroraLedger(params) as LedgerSignerMap[T])
+            .with(Chain.Gnosis, () => GnosisLedger(params) as LedgerSignerMap[T])
+            .with(Chain.Monad, () => MonadLedger(params) as LedgerSignerMap[T])
+            .with(Chain.XLayer, () => XLayerLedger(params) as LedgerSignerMap[T])
+            .otherwise(() => EthereumLedger(params) as LedgerSignerMap[T]);
+        },
+      )
+      .otherwise(() => {
+        throw new SwapKitError("wallet_chain_not_supported", { chain, wallet: WalletOption.LEDGER });
+      })
+  );
+};

package/src/ledger/helpers/getLedgerTransport.ts

@@ -0,0 +1,102 @@
+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/index.ts

@@ -0,0 +1,3 @@
+export { getLedgerAddress } from "./getLedgerAddress";
+export { getLedgerClient } from "./getLedgerClient";
+export { getLedgerTransport } from "./getLedgerTransport";