@swapkit/wallet-hardware 4.2.11 → 4.6.0

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/getLedgerAddress.ts

@@ -1,69 +0,0 @@
-import { Chain, SwapKitError, WalletOption } from "@swapkit/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 SwapKitError("wallet_chain_not_supported", { chain, wallet: WalletOption.LEDGER });
-  }
-};

package/src/ledger/helpers/getLedgerClient.ts

@@ -1,117 +0,0 @@
-import { Chain, type DerivationPathArray, type EVMChain, SwapKitError, WalletOption } from "@swapkit/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("@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.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

@@ -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/index.ts

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

package/src/ledger/index.ts

@@ -1,299 +0,0 @@
-import {
-  Chain,
-  type DerivationPathArray,
-  FeeOption,
-  filterSupportedChains,
-  type GenericTransferParams,
-  getRPCUrl,
-  SwapKitError,
-  THORConfig,
-  WalletOption,
-} from "@swapkit/helpers";
-import type { ThorchainDepositParams } from "@swapkit/toolboxes/cosmos";
-import type { UTXOBuildTxParams } from "@swapkit/toolboxes/utxo";
-
-import { createWallet, getWalletSupportedChains } from "@swapkit/wallet-core";
-import { getLedgerAddress, getLedgerClient } from "./helpers";
-
-export const ledgerWallet = createWallet({
-  connect: ({ addChain, supportedChains, walletType }) =>
-    async function connectLedger(chains: Chain[], derivationPath?: DerivationPathArray) {
-      const [chain] = filterSupportedChains({ chains, supportedChains, walletType });
-
-      if (!chain) return false;
-
-      const walletMethods = await getWalletMethods({ chain, derivationPath });
-
-      addChain({ ...walletMethods, chain, walletType: WalletOption.LEDGER });
-
-      return true;
-    },
-  name: "connectLedger",
-  supportedChains: [
-    Chain.Arbitrum,
-    Chain.Aurora,
-    Chain.Avalanche,
-    Chain.Base,
-    Chain.BinanceSmartChain,
-    Chain.Bitcoin,
-    Chain.BitcoinCash,
-    Chain.Cosmos,
-    Chain.Dash,
-    Chain.Dogecoin,
-    Chain.Ethereum,
-    Chain.Gnosis,
-    Chain.Litecoin,
-    Chain.Monad,
-    Chain.Near,
-    Chain.Optimism,
-    Chain.Polygon,
-    Chain.Ripple,
-    Chain.THORChain,
-    Chain.XLayer,
-    Chain.Tron,
-    Chain.Zcash,
-  ],
-  walletType: WalletOption.LEDGER,
-});
-
-export const LEDGER_SUPPORTED_CHAINS = getWalletSupportedChains(ledgerWallet);
-
-// reduce memo length by removing trade limit
-function reduceMemo(memo?: string, affiliateAddress = "t") {
-  if (!memo?.includes("=:")) return memo;
-
-  const removedAffiliate = memo.includes(`:${affiliateAddress}:`) ? memo.split(`:${affiliateAddress}:`)[0] : memo;
-
-  return removedAffiliate?.substring(0, removedAffiliate.lastIndexOf(":"));
-}
-
-function recursivelyOrderKeys(unordered: any) {
-  // If it's an array - recursively order any
-  // dictionary items within the array
-  if (Array.isArray(unordered)) {
-    unordered.forEach((item, index) => {
-      unordered[index] = recursivelyOrderKeys(item);
-    });
-    return unordered;
-  }
-
-  // If it's an object - let's order the keys
-  if (typeof unordered !== "object") return unordered;
-  const ordered: any = {};
-  const sortedKeys = Object.keys(unordered).sort();
-
-  for (const key of sortedKeys) {
-    ordered[key] = recursivelyOrderKeys(unordered[key]);
-  }
-
-  return ordered;
-}
-
-function stringifyKeysInOrder(data: any) {
-  return JSON.stringify(recursivelyOrderKeys(data));
-}
-
-async function getWalletMethods({ chain, derivationPath }: { chain: Chain; derivationPath?: DerivationPathArray }) {
-  switch (chain) {
-    case Chain.BitcoinCash:
-    case Chain.Bitcoin:
-    case Chain.Dash:
-    case Chain.Dogecoin:
-    case Chain.Litecoin:
-    case Chain.Zcash: {
-      const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
-      const toolbox = await getUtxoToolbox(chain as typeof Chain.Bitcoin);
-
-      const signer = await getLedgerClient({ chain, derivationPath });
-      const address = await getLedgerAddress({ chain, ledgerClient: signer });
-
-      const transfer = async (params: UTXOBuildTxParams) => {
-        const feeRate = params.feeRate || (await toolbox.getFeeRates())[FeeOption.Average];
-        const memo = [Chain.Bitcoin].includes(chain as typeof Chain.Bitcoin) ? params.memo : reduceMemo(params.memo);
-
-        const { psbt, inputs } = await toolbox.createTransaction({
-          ...params,
-          feeRate,
-          fetchTxHex: true,
-          memo,
-          sender: address,
-        });
-        const txHex = await signer.signTransaction(psbt, inputs);
-        const tx = await toolbox.broadcastTx(txHex);
-
-        return tx;
-      };
-
-      return { ...toolbox, address, transfer };
-    }
-
-    case Chain.Ethereum:
-    case Chain.Avalanche:
-    case Chain.Arbitrum:
-    case Chain.Optimism:
-    case Chain.Polygon:
-    case Chain.BinanceSmartChain:
-    case Chain.Base:
-    case Chain.Aurora:
-    case Chain.Gnosis:
-    case Chain.Monad:
-    case Chain.XLayer: {
-      const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
-      const signer = await getLedgerClient({ chain, derivationPath });
-      const address = await getLedgerAddress({ chain, ledgerClient: signer });
-      const toolbox = await getEvmToolbox(chain, { signer });
-
-      return { ...toolbox, address };
-    }
-
-    case Chain.Cosmos: {
-      const { createSigningStargateClient, getMsgSendDenom, getCosmosToolbox } = await import(
-        "@swapkit/toolboxes/cosmos"
-      );
-      const toolbox = await getCosmosToolbox(Chain.Cosmos);
-      const signer = await getLedgerClient({ chain, derivationPath });
-      const address = await getLedgerAddress({ chain, ledgerClient: signer });
-
-      const transfer = async ({ assetValue, recipient, memo }: GenericTransferParams) => {
-        if (!assetValue) throw new SwapKitError("wallet_ledger_invalid_asset");
-
-        const sendCoinsMessage = {
-          amount: [
-            {
-              amount: assetValue.getBaseValue("string"),
-              denom: getMsgSendDenom(`u${assetValue.symbol}`).toLowerCase(),
-            },
-          ],
-          fromAddress: address,
-          toAddress: recipient,
-        };
-
-        const rpcUrl = await getRPCUrl(chain);
-        const signingClient = await createSigningStargateClient(rpcUrl, signer, "0.007uatom");
-
-        const { transactionHash } = await signingClient.signAndBroadcast(
-          address,
-          [{ typeUrl: "/cosmos.bank.v1beta1.MsgSend", value: sendCoinsMessage }],
-          2,
-          memo,
-        );
-
-        return transactionHash;
-      };
-
-      return { ...toolbox, address, transfer };
-    }
-
-    case Chain.THORChain: {
-      const { SignMode } = await import("cosmjs-types/cosmos/tx/signing/v1beta1/signing.js");
-      const { TxRaw } = await import("cosmjs-types/cosmos/tx/v1beta1/tx.js");
-      const importedSigning = await import("@cosmjs/proto-signing");
-      const encodePubkey = importedSigning.encodePubkey ?? importedSigning.default?.encodePubkey;
-      const makeAuthInfoBytes = importedSigning.makeAuthInfoBytes ?? importedSigning.default?.makeAuthInfoBytes;
-      const {
-        createStargateClient,
-        buildEncodedTxBody,
-        getCosmosToolbox,
-        buildAminoMsg,
-        getDefaultChainFee,
-        fromBase64,
-        parseAminoMessageForDirectSigning,
-      } = await import("@swapkit/toolboxes/cosmos");
-      const toolbox = await getCosmosToolbox(chain);
-      const signer = await getLedgerClient({ chain, derivationPath });
-      const address = await getLedgerAddress({ chain, ledgerClient: signer });
-
-      const fee = getDefaultChainFee(chain);
-      const { pubkey: value, signTransaction, sign: signMessage } = signer;
-
-      // ANCHOR (@Chillios): Same parts in methods + can extract StargateClient init to toolbox
-      const thorchainTransfer = async ({
-        memo = "",
-        assetValue,
-        ...rest
-      }: GenericTransferParams | ThorchainDepositParams) => {
-        const account = await toolbox.getAccount(address);
-        if (!account) throw new SwapKitError("wallet_ledger_invalid_account");
-        if (!assetValue) throw new SwapKitError("wallet_ledger_invalid_asset");
-        if (!value) throw new SwapKitError("wallet_ledger_pubkey_not_found");
-
-        const { accountNumber, sequence: sequenceNumber } = account;
-        const sequence = (sequenceNumber || 0).toString();
-
-        const orderedMessages = recursivelyOrderKeys([buildAminoMsg({ assetValue, memo, sender: address, ...rest })]);
-
-        // get tx signing msg
-        const rawSendTx = stringifyKeysInOrder({
-          account_number: accountNumber?.toString(),
-          chain_id: THORConfig.chainId,
-          fee,
-          memo,
-          msgs: orderedMessages,
-          sequence,
-        });
-
-        const signatures = await signTransaction(rawSendTx, sequence);
-        if (!signatures) throw new SwapKitError("wallet_ledger_signing_error");
-
-        const pubkey = encodePubkey({ type: "tendermint/PubKeySecp256k1", value });
-        const msgs = orderedMessages.map(parseAminoMessageForDirectSigning);
-        const bodyBytes = await buildEncodedTxBody({ chain, memo, msgs });
-
-        const authInfoBytes = makeAuthInfoBytes(
-          [{ pubkey, sequence: Number(sequence) }],
-          fee.amount,
-          Number.parseInt(fee.gas, 10),
-          undefined,
-          undefined,
-          SignMode.SIGN_MODE_LEGACY_AMINO_JSON,
-        );
-
-        const signature = signatures?.[0]?.signature ? fromBase64(signatures[0].signature) : Uint8Array.from([]);
-
-        const txRaw = TxRaw.fromPartial({ authInfoBytes, bodyBytes, signatures: [signature] });
-        const txBytes = TxRaw.encode(txRaw).finish();
-        const rpcUrl = await getRPCUrl(Chain.THORChain);
-
-        const broadcaster = await createStargateClient(rpcUrl);
-        const { transactionHash } = await broadcaster.broadcastTx(txBytes);
-
-        return transactionHash;
-      };
-
-      const transfer = (params: GenericTransferParams) => thorchainTransfer(params);
-      const deposit = (params: ThorchainDepositParams) => thorchainTransfer(params);
-
-      return { ...toolbox, address, deposit, signMessage, transfer };
-    }
-
-    case Chain.Near: {
-      const { getNearToolbox } = await import("@swapkit/toolboxes/near");
-      const signer = await getLedgerClient({ chain, derivationPath });
-      const accountId = await signer.getAddress();
-      const toolbox = await getNearToolbox({ signer });
-
-      return { ...toolbox, address: accountId };
-    }
-
-    case Chain.Ripple: {
-      const { getRippleToolbox } = await import("@swapkit/toolboxes/ripple");
-      const signer = await getLedgerClient({ chain, derivationPath });
-      const address = signer.getAddress();
-      const toolbox = await getRippleToolbox({ signer });
-
-      return { ...toolbox, address };
-    }
-
-    case Chain.Tron: {
-      const { createTronToolbox } = await import("@swapkit/toolboxes/tron");
-      const signer = await getLedgerClient({ chain, derivationPath });
-      const address = await getLedgerAddress({ chain, ledgerClient: signer });
-      const toolbox = await createTronToolbox({ signer });
-
-      return { ...toolbox, address };
-    }
-
-    default:
-      throw new SwapKitError("wallet_ledger_chain_not_supported", { chain });
-  }
-}