@swapkit/wallet-hardware 4.2.10 → 4.6.0

package/src/ledger/interfaces/CosmosLedgerInterface.ts

@@ -1,54 +0,0 @@
-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";
-
-  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 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;
-      }
-    }
-  };
-}

package/src/ledger/types.ts

@@ -1,40 +0,0 @@
-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

@@ -1,177 +0,0 @@
-import {
-  type Chain,
-  ChainToChainId,
-  type DerivationPathArray,
-  derivationPathToString,
-  SwapKitError,
-  SwapKitNumber,
-  WalletOption,
-} from "@swapkit/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 SwapKitError({
-            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 SwapKitError({
-          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 SwapKitError("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 SwapKitError({ errorKey: "wallet_missing_params", info: { to } });
-      if (!gasLimit) throw new SwapKitError({ errorKey: "wallet_missing_params", info: { gasLimit } });
-
-      const isEIP1559 = maxFeePerGas && maxPriorityFeePerGas;
-
-      if (isEIP1559 && !maxFeePerGas) {
-        throw new SwapKitError({ errorKey: "wallet_missing_params", info: { maxFeePerGas } });
-      }
-      if (isEIP1559 && !maxPriorityFeePerGas) {
-        throw new SwapKitError({ errorKey: "wallet_missing_params", info: { maxPriorityFeePerGas } });
-      }
-      if (!(isEIP1559 || gasPrice)) {
-        throw new SwapKitError({ errorKey: "wallet_missing_params", info: { gasPrice } });
-      }
-
-      const TrezorConnect = (await import("@trezor/connect-web")).default;
-      const { toHexString } = await import("@swapkit/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 SwapKitError({
-          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 SwapKitNumber(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 SwapKitError({
-          errorKey: "wallet_trezor_failed_to_sign_transaction",
-          info: { chain: this.chain, derivationPath: this.derivationPath },
-        });
-      }
-
-      return serializedTx;
-    };
-
-    connect = (provider: Provider | null) => {
-      if (!provider) {
-        throw new SwapKitError({
-          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 });
-}

package/src/trezor/index.ts

@@ -1,349 +0,0 @@
-import type { ZcashPsbt } from "@bitgo/utxo-lib/dist/src/bitgo";
-import {
-  Chain,
-  type DerivationPathArray,
-  derivationPathToString,
-  FeeOption,
-  filterSupportedChains,
-  type GenericTransferParams,
-  SKConfig,
-  SwapKitError,
-  WalletOption,
-} from "@swapkit/helpers";
-import type { UTXOToolboxes, UTXOType } from "@swapkit/toolboxes/utxo";
-import { createWallet, getWalletSupportedChains } from "@swapkit/wallet-core";
-import { type Psbt, script } from "bitcoinjs-lib";
-
-function getScriptType(derivationPath: DerivationPathArray) {
-  switch (derivationPath[0]) {
-    case 84:
-      return { input: "SPENDWITNESS", output: "PAYTOWITNESS" } as const;
-    case 49:
-      return { input: "SPENDP2SHWITNESS", output: "PAYTOP2SHWITNESS" } as const;
-    case 44:
-      return { input: "SPENDADDRESS", output: "PAYTOADDRESS" } as const;
-    default:
-      return null;
-  }
-}
-
-async function getTrezorWallet<T extends Chain>({
-  chain,
-  derivationPath,
-}: {
-  chain: T;
-  derivationPath: DerivationPathArray;
-}) {
-  switch (chain) {
-    case Chain.Arbitrum:
-    case Chain.Aurora:
-    case Chain.Avalanche:
-    case Chain.Base:
-    case Chain.BinanceSmartChain:
-    case Chain.Ethereum:
-    case Chain.Gnosis:
-    case Chain.Monad:
-    case Chain.Optimism:
-    case Chain.Polygon:
-    case Chain.XLayer: {
-      const { getProvider, getEvmToolbox } = await import("@swapkit/toolboxes/evm");
-      const { getEVMSigner } = await import("./evmSigner");
-
-      const provider = await getProvider(chain);
-      const signer = await getEVMSigner({ chain, derivationPath, provider });
-      const address = await signer.getAddress();
-      const toolbox = await getEvmToolbox(chain, { provider, signer });
-
-      return { ...toolbox, address };
-    }
-
-    case Chain.Zcash: {
-      const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
-
-      const derivationPathStr = derivationPathToString(derivationPath);
-
-      const getAddress = async () => {
-        const TrezorConnect = (await import("@trezor/connect-web")).default;
-        const { success, payload } = await TrezorConnect.getAddress({ coin: "zcash", path: derivationPathStr });
-
-        if (!success) {
-          throw new SwapKitError({
-            errorKey: "wallet_trezor_failed_to_get_address",
-            info: { chain, error: (payload as { error: string; code?: string }).error || "Unknown error" },
-          });
-        }
-
-        return payload.address;
-      };
-
-      const address = await getAddress();
-
-      const signer = {
-        getAddress: async () => address,
-        signTransaction: async (zcashPsbt: ZcashPsbt) => {
-          const TrezorConnect = (await import("@trezor/connect-web")).default;
-          const { address: zcashAddress, networks } = await import("@bitgo/utxo-lib");
-          const address_n = derivationPath.map((pathElement, index) =>
-            index < 3 ? ((pathElement as number) | 0x80000000) >>> 0 : (pathElement as number),
-          );
-
-          const version = 5;
-          const versionGroupId = 0x26a7270a;
-          const branchId = 0x4dec4df0;
-
-          const inputs = zcashPsbt.txInputs.map((input, idx) => ({
-            address_n,
-            amount: zcashPsbt.data.inputs[idx]?.witnessUtxo?.value?.toString() || "0",
-            prev_hash: input.hash.reverse().toString("hex"),
-            prev_index: input.index,
-            script_type: "SPENDADDRESS" as const,
-          }));
-
-          const outputs = zcashPsbt.txOutputs.map((output) => {
-            if (
-              Number(output.value) === 0 &&
-              output.script.length > 0 &&
-              output.script[0] === 0x6a &&
-              script.decompile(output.script)
-            ) {
-              return {
-                amount: "0",
-                op_return_data: (script.decompile(output.script) as any)[1].toString("hex"),
-                script_type: "PAYTOOPRETURN",
-              };
-            }
-
-            const maybeRecipient = zcashAddress.fromOutputScript(output.script, networks.zcash);
-            const isChangeAddress = maybeRecipient === address;
-
-            return isChangeAddress
-              ? { address_n, amount: output.value.toString(), script_type: "PAYTOADDRESS" }
-              : { address: maybeRecipient, amount: output.value.toString(), script_type: "PAYTOADDRESS" };
-          });
-
-          const result = await TrezorConnect.signTransaction({
-            branchId,
-            coin: "zcash",
-            expiry: 0,
-            inputs,
-            locktime: 0,
-            // @ts-expect-error
-            outputs,
-            overwintered: true,
-            version,
-            versionGroupId,
-          });
-
-          if (result.success) {
-            return result.payload.serializedTx;
-          }
-
-          throw new SwapKitError({
-            errorKey: "wallet_trezor_failed_to_sign_transaction",
-            info: { chain, error: (result.payload as { error: string; code?: string }).error },
-          });
-        },
-      };
-
-      const toolbox = await getUtxoToolbox(Chain.Zcash);
-
-      const transfer = async (params: GenericTransferParams) => {
-        if (!(address && params.recipient)) {
-          throw new SwapKitError({
-            errorKey: "wallet_missing_params",
-            info: { address, recipient: params.recipient, wallet: WalletOption.TREZOR },
-          });
-        }
-
-        const feeRate = params.feeRate || (await toolbox.getFeeRates())[params.feeOptionKey || FeeOption.Fast];
-
-        const { psbt } = await toolbox.createTransaction({ ...params, feeRate, fetchTxHex: false, sender: address });
-
-        const txHex = await signer.signTransaction(psbt);
-        const tx = await toolbox.broadcastTx(txHex);
-
-        return tx;
-      };
-
-      return { ...toolbox, address, signTransaction: signer.signTransaction, transfer };
-    }
-
-    case Chain.Bitcoin:
-    case Chain.BitcoinCash:
-    case Chain.Dash:
-    case Chain.Dogecoin:
-    case Chain.Litecoin: {
-      const { toCashAddress, getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
-      const scriptType = getScriptType(derivationPath);
-
-      if (!scriptType) {
-        throw new SwapKitError({ errorKey: "wallet_trezor_derivation_path_not_supported", info: { derivationPath } });
-      }
-
-      const coin = chain.toLowerCase();
-
-      const getAddress = async (path: DerivationPathArray = derivationPath) => {
-        const TrezorConnect = (await import("@trezor/connect-web")).default;
-        const { success, payload } = await TrezorConnect.getAddress({ coin, path: derivationPathToString(path) });
-
-        if (!success) {
-          throw new SwapKitError({
-            errorKey: "wallet_trezor_failed_to_get_address",
-            info: { chain, error: (payload as { error: string; code?: string }).error || "Unknown error" },
-          });
-        }
-
-        if (chain === Chain.BitcoinCash) {
-          const toolbox = await getUtxoToolbox(chain as typeof Chain.BitcoinCash);
-          return toolbox.stripPrefix(payload.address);
-        }
-
-        return payload.address;
-      };
-
-      const address = await getAddress();
-
-      const signTransaction = async (psbt: Psbt, inputs: UTXOType[], memo = "") => {
-        const TrezorConnect = (await import("@trezor/connect-web")).default;
-        const address_n = derivationPath.map((pathElement, index) =>
-          index < 3 ? ((pathElement as number) | 0x80000000) >>> 0 : (pathElement as number),
-        );
-        const toolbox = await getUtxoToolbox(chain as typeof Chain.BitcoinCash);
-
-        const result = await TrezorConnect.signTransaction({
-          coin,
-          inputs: inputs.map(({ hash, index, value }) => ({
-            // Hardens the first 3 elements of the derivation path - required by trezor
-            address_n,
-            // object needs amount but does not use it for signing
-            amount: value,
-            prev_hash: hash,
-            prev_index: index,
-            script_type: scriptType.input,
-          })),
-          outputs: psbt.txOutputs.map((output) => {
-            if (!output.address) {
-              return { amount: "0", op_return_data: Buffer.from(memo).toString("hex"), script_type: "PAYTOOPRETURN" };
-            }
-
-            const outputAddress =
-              chain === Chain.BitcoinCash ? toolbox.stripPrefix(toCashAddress(output.address)) : output.address;
-
-            const isChangeAddress = outputAddress === address;
-
-            return isChangeAddress
-              ? { address_n, amount: output.value, script_type: scriptType.output }
-              : { address: outputAddress, amount: output.value, script_type: "PAYTOADDRESS" };
-          }),
-        });
-
-        if (result.success) {
-          return result.payload.serializedTx;
-        }
-
-        throw new SwapKitError({
-          errorKey: "wallet_trezor_failed_to_sign_transaction",
-          info: { chain, error: (result.payload as { error: string; code?: string }).error },
-        });
-      };
-
-      const transfer = async ({
-        recipient,
-        feeOptionKey,
-        feeRate: paramFeeRate,
-        memo,
-        ...rest
-      }: GenericTransferParams) => {
-        if (!(address && recipient)) {
-          throw new SwapKitError({
-            errorKey: "wallet_missing_params",
-            info: { address, memo, recipient, wallet: WalletOption.TREZOR },
-          });
-        }
-
-        const toolbox = await getUtxoToolbox(chain);
-
-        const feeRate = paramFeeRate || (await toolbox.getFeeRates())[feeOptionKey || FeeOption.Fast];
-
-        const createTxMethod =
-          chain === Chain.BitcoinCash
-            ? (toolbox as UTXOToolboxes["BCH"]).buildTx
-            : (toolbox as UTXOToolboxes["BTC"]).createTransaction;
-
-        const { psbt, inputs } = await createTxMethod({
-          ...rest,
-          feeRate,
-          fetchTxHex: true,
-          memo,
-          recipient,
-          sender: address,
-        });
-
-        const txHex = await signTransaction(psbt, inputs, memo);
-        const tx = await toolbox.broadcastTx(txHex);
-
-        return tx;
-      };
-
-      const toolbox = await getUtxoToolbox(chain);
-
-      return { ...toolbox, address, signTransaction, transfer };
-    }
-
-    default:
-      throw new SwapKitError({ errorKey: "wallet_chain_not_supported", info: { chain, wallet: WalletOption.TREZOR } });
-  }
-}
-
-export const trezorWallet = createWallet({
-  connect: ({ addChain, supportedChains, walletType }) =>
-    async function connectTrezor(chains: Chain[], derivationPath: DerivationPathArray) {
-      const [chain] = filterSupportedChains({ chains, supportedChains, walletType });
-      if (!chain) {
-        throw new SwapKitError({
-          errorKey: "wallet_chain_not_supported",
-          info: { chain, wallet: WalletOption.TREZOR },
-        });
-      }
-
-      const TrezorConnect = (await import("@trezor/connect-web")).default;
-      const { success } = await TrezorConnect.getDeviceState();
-
-      if (!success) {
-        const trezorConfig = SKConfig.get("integrations").trezor;
-        const manifest = trezorConfig
-          ? { ...trezorConfig, appName: (trezorConfig as any).appName || "SwapKit" }
-          : { appName: "SwapKit", appUrl: "", email: "" };
-        TrezorConnect.init({ lazyLoad: true, manifest });
-      }
-
-      const wallet = await getTrezorWallet({ chain, derivationPath });
-
-      addChain({ ...wallet, chain, walletType });
-
-      return true;
-    },
-  name: "connectTrezor",
-  supportedChains: [
-    Chain.Arbitrum,
-    Chain.Aurora,
-    Chain.Avalanche,
-    Chain.Base,
-    Chain.BinanceSmartChain,
-    Chain.Bitcoin,
-    Chain.BitcoinCash,
-    Chain.Dash,
-    Chain.Dogecoin,
-    Chain.Ethereum,
-    Chain.Gnosis,
-    Chain.Litecoin,
-    Chain.Monad,
-    Chain.Optimism,
-    Chain.Polygon,
-    Chain.XLayer,
-    Chain.Zcash,
-  ],
-  walletType: WalletOption.TREZOR,
-});
-
-export const TREZOR_SUPPORTED_CHAINS = getWalletSupportedChains(trezorWallet);