@tcswap/wallet-hardware 4.2.16

package/src/ledger/helpers/index.ts

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

package/src/ledger/index.ts

@@ -0,0 +1,303 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import {
+  Chain,
+  type DerivationPathArray,
+  FeeOption,
+  filterSupportedChains,
+  type GenericTransferParams,
+  getRPCUrl,
+  THORConfig,
+  USwapError,
+  WalletOption,
+} from "@tcswap/helpers";
+import type { ThorchainDepositParams } from "@tcswap/toolboxes/cosmos";
+import type { UTXOBuildTxParams } from "@tcswap/toolboxes/utxo";
+
+import { createWallet, getWalletSupportedChains } from "@tcswap/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("@tcswap/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("@tcswap/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(
+        "@tcswap/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 USwapError("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("@tcswap/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 USwapError("wallet_ledger_invalid_account");
+        if (!assetValue) throw new USwapError("wallet_ledger_invalid_asset");
+        if (!value) throw new USwapError("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 USwapError("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("@tcswap/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("@tcswap/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("@tcswap/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 USwapError("wallet_ledger_chain_not_supported", { chain });
+  }
+}

package/src/ledger/interfaces/CosmosLedgerInterface.ts

@@ -0,0 +1,58 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { type DerivationPathArray, LedgerErrorCode, NetworkDerivationPath, USwapError } from "@tcswap/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";
+
+  checkOrCreateTransportAndLedger = async (forceReconnect = false) => {
+    if (!forceReconnect && this.transport && this.ledgerApp) return;
+
+    try {
+      this.transport = forceReconnect || !this.transport ? await getLedgerTransport() : this.transport;
+
+      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 USwapError("wallet_ledger_connection_error", error);
+    }
+  };
+
+  validateResponse = (errorCode: LedgerErrorCode, message?: string) => {
+    switch (errorCode) {
+      case LedgerErrorCode.NoError:
+        return;
+
+      case LedgerErrorCode.LockedDevice:
+        throw new USwapError("wallet_ledger_device_locked", { message: `Ledger is locked: ${message}` });
+
+      case LedgerErrorCode.TC_NotFound:
+        throw new USwapError("wallet_ledger_device_not_found");
+
+      default: {
+        break;
+      }
+    }
+  };
+}

package/src/ledger/types.ts

@@ -0,0 +1,40 @@
+import type { CosmosLedger } from "./clients/cosmos";
+import type {
+  ArbitrumLedger,
+  AuroraLedger,
+  AvalancheLedger,
+  BaseLedger,
+  BinanceSmartChainLedger,
+  EthereumLedger,
+  GnosisLedger,
+  OptimismLedger,
+  PolygonLedger,
+} from "./clients/evm";
+import type { THORChainLedger } from "./clients/thorchain";
+import type { TronLedger } from "./clients/tron";
+import type { BitcoinCashLedger, BitcoinLedger, DogecoinLedger, LitecoinLedger } from "./clients/utxo";
+
+export type UTXOLedgerClients =
+  | ReturnType<typeof BitcoinLedger>
+  | ReturnType<typeof BitcoinCashLedger>
+  | ReturnType<typeof DogecoinLedger>
+  | ReturnType<typeof LitecoinLedger>;
+export type CosmosLedgerClients = CosmosLedger | THORChainLedger;
+export type EVMLedgerClients =
+  | ReturnType<typeof ArbitrumLedger>
+  | ReturnType<typeof AuroraLedger>
+  | ReturnType<typeof AvalancheLedger>
+  | ReturnType<typeof BaseLedger>
+  | ReturnType<typeof BinanceSmartChainLedger>
+  | ReturnType<typeof GnosisLedger>
+  | ReturnType<typeof EthereumLedger>
+  | ReturnType<typeof OptimismLedger>
+  | ReturnType<typeof PolygonLedger>;
+export type TronLedgerClient = ReturnType<typeof TronLedger>;
+
+export type GetAddressAndPubKeyResponse = {
+  bech32_address: string;
+  compressed_pk: any;
+  error_message: string;
+  return_code: number;
+};

package/src/trezor/evmSigner.ts

@@ -0,0 +1,181 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import {
+  type Chain,
+  ChainToChainId,
+  type DerivationPathArray,
+  derivationPathToString,
+  USwapError,
+  USwapNumber,
+  WalletOption,
+} from "@tcswap/helpers";
+import type { JsonRpcProvider, Provider, TransactionRequest } from "ethers";
+
+type TrezorEVMSignerParams = {
+  chain: Chain;
+  derivationPath: DerivationPathArray;
+  provider: Provider | JsonRpcProvider;
+};
+
+export async function getEVMSigner({ chain, derivationPath, provider }: TrezorEVMSignerParams) {
+  const { AbstractSigner, Signature } = await import("ethers");
+
+  class TrezorSigner extends AbstractSigner {
+    address: string;
+    chain: Chain;
+    derivationPath: DerivationPathArray;
+    readonly provider: Provider | JsonRpcProvider;
+
+    constructor({ chain, derivationPath, provider }: TrezorEVMSignerParams) {
+      super(provider);
+
+      this.address = "";
+      this.chain = chain;
+      this.derivationPath = derivationPath;
+      this.provider = provider;
+    }
+
+    getAddress = async () => {
+      if (!this.address) {
+        const TrezorConnect = (await import("@trezor/connect-web")).default;
+
+        const result = await TrezorConnect.ethereumGetAddress({
+          path: derivationPathToString(this.derivationPath),
+          showOnTrezor: true,
+        });
+
+        if (!result.success) {
+          throw new USwapError({
+            errorKey: "wallet_trezor_failed_to_get_address",
+            info: { ...result, chain: this.chain, derivationPath: this.derivationPath },
+          });
+        }
+
+        this.address = result.payload.address;
+      }
+
+      return this.address;
+    };
+
+    signMessage = async (message: string) => {
+      const TrezorConnect = (await import("@trezor/connect-web")).default;
+
+      const result = await TrezorConnect.ethereumSignMessage({
+        message,
+        path: derivationPathToString(this.derivationPath),
+      });
+
+      if (!result.success) {
+        throw new USwapError({
+          errorKey: "wallet_trezor_failed_to_sign_transaction",
+          info: { ...result, chain: this.chain, derivationPath: this.derivationPath, message },
+        });
+      }
+
+      return result.payload.signature;
+    };
+
+    signTypedData(): Promise<string> {
+      throw new USwapError("wallet_trezor_method_not_supported", { method: "signTypedData" });
+    }
+
+    signTransaction = async ({
+      to,
+      gasLimit,
+      value,
+      data,
+      nonce,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      gasPrice,
+      // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: any: refactor
+    }: TransactionRequest) => {
+      if (!to) throw new USwapError({ errorKey: "wallet_missing_params", info: { to } });
+      if (!gasLimit) throw new USwapError({ errorKey: "wallet_missing_params", info: { gasLimit } });
+
+      const isEIP1559 = maxFeePerGas && maxPriorityFeePerGas;
+
+      if (isEIP1559 && !maxFeePerGas) {
+        throw new USwapError({ errorKey: "wallet_missing_params", info: { maxFeePerGas } });
+      }
+      if (isEIP1559 && !maxPriorityFeePerGas) {
+        throw new USwapError({ errorKey: "wallet_missing_params", info: { maxPriorityFeePerGas } });
+      }
+      if (!(isEIP1559 || gasPrice)) {
+        throw new USwapError({ errorKey: "wallet_missing_params", info: { gasPrice } });
+      }
+
+      const TrezorConnect = (await import("@trezor/connect-web")).default;
+      const { toHexString } = await import("@tcswap/toolboxes/evm");
+      const { Transaction } = await import("ethers");
+
+      const additionalFields = isEIP1559
+        ? {
+            maxFeePerGas: toHexString(BigInt(maxFeePerGas?.toString() || 0)),
+            maxPriorityFeePerGas: toHexString(BigInt(maxPriorityFeePerGas?.toString() || 0)),
+          }
+        : (gasPrice && { gasPrice: toHexString(BigInt(gasPrice?.toString() || 0)) }) || { gasPrice: "0x0" };
+
+      const hexifiedNonce = toHexString(
+        BigInt(nonce || (await this.provider.getTransactionCount(await this.getAddress(), "pending"))),
+      );
+
+      const formattedTx = {
+        chainId: Number.parseInt(ChainToChainId[this.chain], 10),
+        data: data?.toString() || "0x",
+        gasLimit: toHexString(BigInt(gasLimit?.toString() || 0)),
+        nonce: hexifiedNonce,
+        to: to.toString(),
+        value: toHexString(BigInt(value?.toString() || 0)),
+        ...additionalFields,
+      };
+
+      const { success, payload } = await TrezorConnect.ethereumSignTransaction({
+        path: derivationPathToString(this.derivationPath),
+        transaction: formattedTx,
+      });
+
+      if (!success) {
+        throw new USwapError({
+          errorKey: "wallet_trezor_failed_to_sign_transaction",
+          info: { ...payload, chain: this.chain, derivationPath: this.derivationPath },
+        });
+      }
+
+      const { r, s, v } = payload;
+
+      const signature = Signature.from({ r, s, v: new USwapNumber(BigInt(v)).getBaseValue("number") });
+
+      const serializedTx = Transaction.from({
+        ...formattedTx,
+        nonce: Number.parseInt(formattedTx.nonce, 16),
+        signature,
+        type: isEIP1559 ? 2 : 0,
+      }).serialized;
+
+      if (!serializedTx) {
+        throw new USwapError({
+          errorKey: "wallet_trezor_failed_to_sign_transaction",
+          info: { chain: this.chain, derivationPath: this.derivationPath },
+        });
+      }
+
+      return serializedTx;
+    };
+
+    connect = (provider: Provider | null) => {
+      if (!provider) {
+        throw new USwapError({
+          errorKey: "wallet_provider_not_found",
+          info: { chain: this.chain, derivationPath: this.derivationPath, wallet: WalletOption.TREZOR },
+        });
+      }
+
+      return new TrezorSigner({ chain: this.chain, derivationPath: this.derivationPath, provider });
+    };
+  }
+
+  return new TrezorSigner({ chain, derivationPath, provider });
+}