@tcswap/wallet-hardware 4.2.16

package/src/ledger/clients/tron.ts

@@ -0,0 +1,84 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import type TronApp from "@ledgerhq/hw-app-trx";
+import { type DerivationPathArray, derivationPathToString, NetworkDerivationPath, USwapError } from "@tcswap/helpers";
+import type { TronSignedTransaction, TronSigner, TronTransaction } from "@tcswap/toolboxes/tron";
+
+import { getLedgerTransport } from "../helpers/getLedgerTransport";
+
+export class TronLedgerInterface implements TronSigner {
+  derivationPath: string;
+  ledgerApp: InstanceType<typeof TronApp> | null = null;
+  ledgerTimeout = 50000;
+
+  constructor(derivationPath?: DerivationPathArray | string) {
+    this.derivationPath =
+      typeof derivationPath === "string"
+        ? derivationPath
+        : derivationPathToString(derivationPath || NetworkDerivationPath.TRON);
+  }
+
+  checkOrCreateTransportAndLedger = async () => {
+    if (this.ledgerApp) return;
+    await this.createTransportAndLedger();
+  };
+
+  createTransportAndLedger = async () => {
+    const transport = await getLedgerTransport();
+    const TronApp = (await import("@ledgerhq/hw-app-trx")).default;
+
+    this.ledgerApp = new TronApp(transport);
+  };
+
+  getAddress = async (): Promise<string> => {
+    const response = await this.getAddressAndPubKey();
+    if (!response) throw new USwapError("wallet_ledger_failed_to_get_address");
+    return response.address;
+  };
+
+  getAddressAndPubKey = async () => {
+    await this.createTransportAndLedger();
+    const result = await this.ledgerApp?.getAddress(this.derivationPath);
+
+    if (!result) throw new USwapError("wallet_ledger_failed_to_get_address");
+
+    return { address: result.address, publicKey: result.publicKey };
+  };
+
+  showAddressAndPubKey = async () => {
+    await this.createTransportAndLedger();
+    return this.ledgerApp?.getAddress(this.derivationPath, true);
+  };
+
+  signTransaction = async (transaction: TronTransaction): Promise<TronSignedTransaction> => {
+    await this.createTransportAndLedger();
+
+    if (!this.ledgerApp) {
+      throw new USwapError("wallet_ledger_transport_error");
+    }
+
+    // Tron transactions need to be serialized before signing
+    const serializedTx = JSON.stringify(transaction);
+
+    try {
+      const signature = await this.ledgerApp.signTransaction(
+        this.derivationPath,
+        serializedTx,
+        [], // Token signatures array - empty for native TRX transfers
+      );
+
+      if (!signature) {
+        throw new USwapError("wallet_ledger_signing_error");
+      }
+
+      // Return the signed transaction in Tron's expected format
+      return { ...transaction, signature: [signature] };
+    } catch (error) {
+      throw new USwapError("wallet_ledger_signing_error", { error });
+    }
+  };
+}
+
+export const TronLedger = (derivationPath?: DerivationPathArray) => new TronLedgerInterface(derivationPath);

package/src/ledger/clients/utxo.ts

@@ -0,0 +1,158 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import type BitcoinApp from "@ledgerhq/hw-app-btc";
+import type { CreateTransactionArg } from "@ledgerhq/hw-app-btc/lib-es/createTransaction";
+import { type DerivationPathArray, derivationPathToString, getWalletFormatFor, USwapError } from "@tcswap/helpers";
+import type { UTXOType } from "@tcswap/toolboxes/utxo";
+import type { Psbt } from "bitcoinjs-lib";
+
+import { getLedgerTransport } from "../helpers/getLedgerTransport";
+
+const nonSegwitLedgerChains = ["bitcoin-cash", "dash", "dogecoin", "zcash"];
+
+type Params = {
+  psbt: Psbt;
+  inputUtxos: UTXOType[];
+  btcApp: BitcoinApp;
+  derivationPath: string;
+  chain: "bitcoin-cash" | "bitcoin" | "litecoin" | "dogecoin" | "dash" | "zcash";
+};
+
+const signUTXOTransaction = (
+  { psbt, inputUtxos, btcApp, derivationPath, chain }: Params,
+  options?: Partial<CreateTransactionArg>,
+) => {
+  const inputs = inputUtxos.map((item) => {
+    const splitTx = btcApp.splitTransaction(
+      item.txHex || "",
+      !nonSegwitLedgerChains.includes(chain),
+      chain === "zcash",
+    );
+
+    return [splitTx, item.index, undefined as string | null | undefined, undefined as number | null | undefined] as any;
+  });
+
+  const newTxHex = psbt.data.globalMap.unsignedTx.toBuffer().toString("hex");
+
+  const splitNewTx = btcApp.splitTransaction(newTxHex, true);
+  const outputScriptHex = btcApp.serializeTransactionOutputs(splitNewTx).toString("hex");
+
+  const params: CreateTransactionArg = {
+    additionals: ["bech32"],
+    associatedKeysets: inputs.map(() => derivationPath),
+    inputs,
+    outputScriptHex,
+    segwit: true,
+    useTrustedInputForSegwit: true,
+  };
+
+  return btcApp.createPaymentTransaction({ ...params, ...options });
+};
+
+const BaseLedgerUTXO = ({
+  chain,
+  additionalSignParams,
+}: {
+  chain: "bitcoin-cash" | "bitcoin" | "litecoin" | "dogecoin" | "dash" | "zcash";
+  additionalSignParams?: Partial<CreateTransactionArg>;
+}) => {
+  let btcApp: InstanceType<typeof BitcoinApp>;
+  let transport: any = null;
+
+  async function checkBtcAppAndCreateTransportWebUSB(checkBtcApp = true) {
+    if (checkBtcApp && !btcApp) {
+      new USwapError("wallet_ledger_connection_error", {
+        message: `Ledger connection failed:\n${JSON.stringify({ btcApp, checkBtcApp })}`,
+      });
+    }
+
+    transport ||= await getLedgerTransport();
+  }
+
+  async function createTransportWebUSB() {
+    transport = await getLedgerTransport();
+    const BitcoinApp = (await import("@ledgerhq/hw-app-btc")).default;
+
+    btcApp = new BitcoinApp({ currency: chain, transport });
+  }
+
+  return (derivationPathArray?: DerivationPathArray | string) => {
+    const derivationPath =
+      typeof derivationPathArray === "string"
+        ? derivationPathArray
+        : derivationPathToString(derivationPathArray as DerivationPathArray);
+
+    const format = getWalletFormatFor(derivationPath);
+
+    return {
+      connect: async () => {
+        await checkBtcAppAndCreateTransportWebUSB(false);
+        const BitcoinApp = (await import("@ledgerhq/hw-app-btc")).default;
+
+        btcApp = new BitcoinApp({ currency: chain, transport });
+      },
+      getAddress: async () => {
+        const { toCashAddress } = await import("@tcswap/toolboxes/utxo");
+
+        await checkBtcAppAndCreateTransportWebUSB(false);
+
+        const { bitcoinAddress: address } = await btcApp.getWalletPublicKey(derivationPath, { format });
+
+        if (!address) {
+          throw new USwapError("wallet_ledger_get_address_error", {
+            message: `Cannot get ${chain} address from ledger derivation path: ${derivationPath}`,
+          });
+        }
+
+        return chain === "bitcoin-cash" && format === "legacy"
+          ? toCashAddress(address).replace(/(bchtest:|bitcoincash:)/, "")
+          : address;
+      },
+      getExtendedPublicKey: async (path = "84'/0'/0'", xpubVersion = 76067358) => {
+        await checkBtcAppAndCreateTransportWebUSB(false);
+
+        return btcApp.getWalletXpub({ path, xpubVersion });
+      },
+      signTransaction: async (psbt: Psbt, inputUtxos: UTXOType[]) => {
+        await createTransportWebUSB();
+
+        return signUTXOTransaction({ btcApp, chain, derivationPath, inputUtxos, psbt }, additionalSignParams);
+      },
+    };
+  };
+};
+
+export const BitcoinLedger = BaseLedgerUTXO({ chain: "bitcoin" });
+export const LitecoinLedger = BaseLedgerUTXO({ chain: "litecoin" });
+
+export const BitcoinCashLedger = BaseLedgerUTXO({
+  additionalSignParams: { additionals: ["abc"], segwit: false, sigHashType: 0x41 },
+  chain: "bitcoin-cash",
+});
+
+export const DogecoinLedger = BaseLedgerUTXO({
+  additionalSignParams: { additionals: [], segwit: false, useTrustedInputForSegwit: false },
+  chain: "dogecoin",
+});
+
+export const DashLedger = BaseLedgerUTXO({
+  additionalSignParams: { additionals: [], segwit: false, useTrustedInputForSegwit: false },
+  chain: "dash",
+});
+
+export const ZcashLedger = BaseLedgerUTXO({
+  additionalSignParams: {
+    additionals: ["zcash", "sapling"],
+    expiryHeight: (() => {
+      const buf = Buffer.allocUnsafe(4);
+      buf.writeUInt32LE(0);
+      return buf;
+    })(),
+    lockTime: 0,
+    segwit: false,
+    useTrustedInputForSegwit: false,
+  },
+  chain: "zcash",
+});

package/src/ledger/clients/xrp.ts

@@ -0,0 +1,50 @@
+import Xrp from "@ledgerhq/hw-app-xrp";
+import type Transport from "@ledgerhq/hw-transport";
+import { Chain, type DerivationPathArray, derivationPathToString, NetworkDerivationPath } from "@tcswap/helpers";
+import type { Transaction } from "@tcswap/toolboxes/ripple";
+import { encode } from "ripple-binary-codec";
+import type { Payment } from "xrpl";
+import { getLedgerTransport } from "../helpers/getLedgerTransport";
+
+const TF_FULLY_CANONICAL_SIG = 2147483648;
+
+function cleanTransactionObject(obj: Record<string, any>) {
+  const cleaned: Record<string, any> = {};
+  for (const key in obj) {
+    if (obj[key] !== null && obj[key] !== undefined) {
+      cleaned[key] = obj[key];
+    }
+  }
+  return cleaned;
+}
+
+function establishConnection(transport: Transport) {
+  return new Xrp(transport);
+}
+
+export const XRPLedger = async (derivationPath?: DerivationPathArray) => {
+  const path = derivationPathToString(derivationPath || NetworkDerivationPath[Chain.Ripple]);
+  const transport = await getLedgerTransport();
+  const xrpInstance = establishConnection(transport);
+
+  const { address, publicKey } = await xrpInstance.getAddress(path);
+
+  async function signTransaction(transaction: Payment | Transaction) {
+    const { hashes } = await import("@tcswap/toolboxes/ripple");
+    const cleanedTxWithPubKey = cleanTransactionObject(transaction);
+    const transactionJSON = {
+      ...cleanedTxWithPubKey,
+      Flags: transaction.Flags || TF_FULLY_CANONICAL_SIG,
+      SigningPubKey: publicKey.toUpperCase(),
+    };
+
+    const transactionToSignOnLedger = encode(transactionJSON);
+    const txnSignature = await xrpInstance.signTransaction(path, transactionToSignOnLedger);
+    const tx_blob = encode({ ...transactionJSON, TxnSignature: txnSignature });
+    const hash = hashes.hashSignedTx(tx_blob);
+
+    return { hash, tx_blob };
+  }
+
+  return { getAddress: () => address, signTransaction };
+};

package/src/ledger/cosmosTypes.ts

@@ -0,0 +1,102 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { USwapError } from "@tcswap/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 USwapError("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 USwapError("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 USwapError("wallet_ledger_invalid_params", {
+        reason: `Amino type identifier '${type}' does not exist in the Amino message type register.`,
+      });
+    }
+
+    if (matches.length > 1) {
+      throw new USwapError("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/getLedgerAddress.ts

@@ -0,0 +1,73 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { Chain, USwapError, WalletOption } from "@tcswap/helpers";
+
+import type { getNearLedgerClient } from "../clients/near";
+import type { TronLedger } from "../clients/tron";
+import type { XRPLedger } from "../clients/xrp";
+import type { LEDGER_SUPPORTED_CHAINS } from "../index";
+import type { CosmosLedgerClients, EVMLedgerClients, UTXOLedgerClients } from "../types";
+import type { getLedgerClient } from "./getLedgerClient";
+
+export const getLedgerAddress = async <
+  T extends (typeof LEDGER_SUPPORTED_CHAINS)[number],
+  L extends Awaited<ReturnType<typeof getLedgerClient<T>>>,
+>({
+  chain,
+  ledgerClient,
+}: {
+  chain: T;
+  ledgerClient: L;
+}) => {
+  if (!ledgerClient) return "";
+
+  switch (chain) {
+    case Chain.Cosmos:
+    case Chain.THORChain: {
+      return (ledgerClient as CosmosLedgerClients).connect();
+    }
+
+    case Chain.Ethereum:
+    case Chain.BinanceSmartChain:
+    case Chain.Avalanche:
+    case Chain.Polygon:
+    case Chain.Arbitrum:
+    case Chain.Optimism:
+    case Chain.Base:
+    case Chain.Aurora:
+    case Chain.Gnosis:
+    case Chain.XLayer: {
+      return (ledgerClient as EVMLedgerClients).getAddress();
+    }
+
+    case Chain.Bitcoin:
+    case Chain.BitcoinCash:
+    case Chain.Dash:
+    case Chain.Dogecoin:
+    case Chain.Litecoin:
+    case Chain.Zcash: {
+      const ledger = ledgerClient as UTXOLedgerClients;
+      await ledger.connect();
+      const address = await ledger.getAddress();
+
+      return chain === Chain.BitcoinCash ? address.replace("bitcoincash:", "") : address;
+    }
+
+    case Chain.Near: {
+      return await (ledgerClient as Awaited<ReturnType<typeof getNearLedgerClient>>).getAddress();
+    }
+
+    case Chain.Ripple: {
+      return (ledgerClient as Awaited<ReturnType<typeof XRPLedger>>).getAddress();
+    }
+
+    case Chain.Tron: {
+      return (ledgerClient as Awaited<ReturnType<typeof TronLedger>>).getAddress();
+    }
+
+    default:
+      throw new USwapError("wallet_chain_not_supported", { chain, wallet: WalletOption.LEDGER });
+  }
+};

package/src/ledger/helpers/getLedgerClient.ts

@@ -0,0 +1,121 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { Chain, type DerivationPathArray, type EVMChain, USwapError, WalletOption } from "@tcswap/helpers";
+
+import { CosmosLedger } from "../clients/cosmos";
+import {
+  ArbitrumLedger,
+  AuroraLedger,
+  AvalancheLedger,
+  BaseLedger,
+  BinanceSmartChainLedger,
+  EthereumLedger,
+  GnosisLedger,
+  MonadLedger,
+  OptimismLedger,
+  PolygonLedger,
+  XLayerLedger,
+} from "../clients/evm";
+import { getNearLedgerClient } from "../clients/near";
+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.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.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]))
+      // @ts-expect-error
+      .with(Chain.Near, () => {
+        return Promise.resolve(getNearLedgerClient(derivationPath));
+      })
+      .with(
+        Chain.Arbitrum,
+        Chain.Aurora,
+        Chain.Avalanche,
+        Chain.BinanceSmartChain,
+        Chain.Ethereum,
+        Chain.Gnosis,
+        Chain.Monad,
+        Chain.Optimism,
+        Chain.Polygon,
+        Chain.Base,
+        Chain.XLayer,
+        async () => {
+          const { getProvider } = await import("@tcswap/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.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 USwapError("wallet_chain_not_supported", { chain, wallet: WalletOption.LEDGER });
+      })
+  );
+};

package/src/ledger/helpers/getLedgerTransport.ts

@@ -0,0 +1,106 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import type Transport from "@ledgerhq/hw-transport";
+import { USwapError } from "@tcswap/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 USwapError("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 USwapError("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 USwapError("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 USwapError("wallet_ledger_connection_claimed", error);
+  }
+
+  const Transport = (await import("@ledgerhq/hw-transport-webusb")).default;
+  const isSupported = await Transport.isSupported();
+  if (!isSupported) throw new USwapError("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;
+};