@swapkit/wallet-hardware 6.1.1 → 6.3.0

package/src/ledger/helpers/getLedgerAddress.ts

@@ -1,7 +1,10 @@
 import { Chain, SwapKitError, WalletOption } from "@swapkit/helpers";
 
+import type { CardanoLedger } from "../clients/cardano";
 import type { getNearLedgerClient } from "../clients/near";
+import type { StellarLedger } from "../clients/stellar";
 import type { SuiLedger } from "../clients/sui";
+import type { TONLedger } from "../clients/ton";
 import type { TronLedger } from "../clients/tron";
 import type { XRPLedger } from "../clients/xrp";
 import type { LEDGER_SUPPORTED_CHAINS } from "../index";
@@ -38,6 +41,7 @@ export const getLedgerAddress = async <
     case Chain.Aurora:
     case Chain.Gnosis:
     case Chain.Monad:
+    case Chain.Robinhood:
     case Chain.XLayer: {
       return (ledgerClient as EVMLedgerClients).getAddress();
     }
@@ -63,6 +67,14 @@ export const getLedgerAddress = async <
       return (ledgerClient as Awaited<ReturnType<typeof XRPLedger>>).getAddress();
     }
 
+    case Chain.Stellar: {
+      return (ledgerClient as Awaited<ReturnType<typeof StellarLedger>>).getAddress();
+    }
+
+    case Chain.Cardano: {
+      return (ledgerClient as Awaited<ReturnType<typeof CardanoLedger>>).getAddress();
+    }
+
     case Chain.Tron: {
       return (ledgerClient as Awaited<ReturnType<typeof TronLedger>>).getAddress();
     }
@@ -71,6 +83,10 @@ export const getLedgerAddress = async <
       return (ledgerClient as Awaited<ReturnType<typeof SuiLedger>>).connect();
     }
 
+    case Chain.Ton: {
+      return (ledgerClient as Awaited<ReturnType<typeof TONLedger>>).getAddress();
+    }
+
     default:
       throw new SwapKitError("wallet_chain_not_supported", { chain, wallet: WalletOption.LEDGER });
   }

package/src/ledger/helpers/getLedgerClient.ts

@@ -9,6 +9,7 @@ import {
   WalletOption,
 } from "@swapkit/helpers";
 import { BitcoinLedger } from "../clients/bitcoin";
+import { CardanoLedger } from "../clients/cardano";
 import { CosmosLedger } from "../clients/cosmos";
 import {
   ArbitrumLedger,
@@ -23,11 +24,14 @@ import {
   MonadLedger,
   OptimismLedger,
   PolygonLedger,
+  RobinhoodLedger,
   XLayerLedger,
 } from "../clients/evm";
 import { getNearLedgerClient } from "../clients/near";
+import { StellarLedger } from "../clients/stellar";
 import { SuiLedger } from "../clients/sui";
 import { THORChainLedger } from "../clients/thorchain";
+import { TONLedger } from "../clients/ton";
 import { TronLedger } from "../clients/tron";
 import { BitcoinCashLedger, DashLedger, DogecoinLedger, LitecoinLedger } from "../clients/utxo";
 import { XRPLedger } from "../clients/xrp";
@@ -45,6 +49,7 @@ type LedgerSignerMap = {
   [Chain.BinanceSmartChain]: ReturnType<typeof BinanceSmartChainLedger>;
   [Chain.BitcoinCash]: ReturnType<typeof BitcoinCashLedger>;
   [Chain.Bitcoin]: ReturnType<typeof BitcoinLedger>;
+  [Chain.Cardano]: ReturnType<typeof CardanoLedger>;
   [Chain.Cosmos]: CosmosLedger;
   [Chain.Dash]: ReturnType<typeof DashLedger>;
   [Chain.Dogecoin]: ReturnType<typeof DogecoinLedger>;
@@ -56,8 +61,11 @@ type LedgerSignerMap = {
   [Chain.Optimism]: ReturnType<typeof OptimismLedger>;
   [Chain.Polygon]: ReturnType<typeof PolygonLedger>;
   [Chain.Ripple]: ReturnType<typeof XRPLedger>;
+  [Chain.Robinhood]: ReturnType<typeof RobinhoodLedger>;
+  [Chain.Stellar]: ReturnType<typeof StellarLedger>;
   [Chain.Sui]: ReturnType<typeof SuiLedger>;
   [Chain.THORChain]: THORChainLedger;
+  [Chain.Ton]: ReturnType<typeof TONLedger>;
   [Chain.Tron]: ReturnType<typeof TronLedger>;
   [Chain.XLayer]: ReturnType<typeof XLayerLedger>;
   [Chain.Zcash]: ReturnType<typeof ZcashLedger>;
@@ -114,8 +122,11 @@ export async function getLedgerClient<T extends LedgerSupportedChain>({
     .with(Chain.Litecoin, () => Promise.resolve(LitecoinLedger(clientParams) as LedgerSignerMap[T]))
     .with(Chain.Zcash, () => Promise.resolve(ZcashLedger(clientParams) as LedgerSignerMap[T]))
     .with(Chain.Ripple, () => Promise.resolve(XRPLedger(clientParams) as LedgerSignerMap[T]))
+    .with(Chain.Stellar, () => Promise.resolve(StellarLedger(clientParams) as LedgerSignerMap[T]))
+    .with(Chain.Cardano, () => Promise.resolve(CardanoLedger(clientParams) as LedgerSignerMap[T]))
     .with(Chain.Tron, () => Promise.resolve(TronLedger(clientParams) as LedgerSignerMap[T]))
     .with(Chain.Sui, () => Promise.resolve(SuiLedger(clientParams) as LedgerSignerMap[T]))
+    .with(Chain.Ton, () => Promise.resolve(TONLedger(clientParams) as LedgerSignerMap[T]))
     .with(Chain.Near, () => Promise.resolve(getNearLedgerClient(clientParams) as LedgerSignerMap[T]))
     .with(
       Chain.Arbitrum,
@@ -130,6 +141,7 @@ export async function getLedgerClient<T extends LedgerSupportedChain>({
       Chain.Optimism,
       Chain.Polygon,
       Chain.Base,
+      Chain.Robinhood,
       Chain.XLayer,
       async () => {
         const { getProvider } = await import("@swapkit/toolboxes/evm");
@@ -154,6 +166,7 @@ export async function getLedgerClient<T extends LedgerSupportedChain>({
           .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.Robinhood, () => RobinhoodLedger(params) as LedgerSignerMap[T])
           .with(Chain.XLayer, () => XLayerLedger(params) as LedgerSignerMap[T])
           .otherwise(() => EthereumLedger(params) as LedgerSignerMap[T]);
       },

package/src/ledger/index.ts

@@ -1,12 +1,13 @@
 import type Transport from "@ledgerhq/hw-transport";
 import { hex } from "@scure/base";
 import {
-  type AssetValue,
+  AssetValue,
   Chain,
   type DerivationPathArray,
   derivationPathToString,
   FeeOption,
   filterSupportedChains,
+  type GenericTransferParams,
   getUTXOScriptTypeForPath,
   NetworkDerivationPath,
   SwapKitError,
@@ -14,6 +15,7 @@ import {
   UTXOScriptType,
   WalletOption,
 } from "@swapkit/helpers";
+import type { TONTransactionInput } from "@swapkit/toolboxes/ton";
 import {
   addInputsAndOutputs,
   assertDerivationIndex,
@@ -92,6 +94,7 @@ const LEDGER_SUPPORTED_CHAINS_CONFIG = [
   Chain.BinanceSmartChain,
   Chain.Bitcoin,
   Chain.BitcoinCash,
+  Chain.Cardano,
   Chain.Cosmos,
   Chain.Dash,
   Chain.Dogecoin,
@@ -103,8 +106,11 @@ const LEDGER_SUPPORTED_CHAINS_CONFIG = [
   Chain.Optimism,
   Chain.Polygon,
   Chain.Ripple,
+  Chain.Robinhood,
+  Chain.Stellar,
   Chain.Sui,
   Chain.THORChain,
+  Chain.Ton,
   Chain.XLayer,
   Chain.Tron,
   Chain.Zcash,
@@ -134,6 +140,7 @@ const LEDGER_EVM_CHAINS = [
   Chain.Aurora,
   Chain.Gnosis,
   Chain.Monad,
+  Chain.Robinhood,
   Chain.XLayer,
 ] as const satisfies readonly LedgerSupportedChain[];
 
@@ -169,35 +176,26 @@ export const ledgerWallet = createWallet({
 
       return true;
     },
-  directSigningSupport: {
-    [Chain.Arbitrum]: true,
-    [Chain.Arc]: true,
-    [Chain.Aurora]: true,
-    [Chain.Avalanche]: true,
-    [Chain.Base]: true,
-    [Chain.Berachain]: true,
-    [Chain.BinanceSmartChain]: true,
-    [Chain.Ethereum]: true,
-    [Chain.Gnosis]: true,
-    [Chain.Monad]: true,
-    [Chain.Bitcoin]: true,
-    [Chain.BitcoinCash]: true,
-    [Chain.Cosmos]: true,
-    [Chain.Dash]: true,
-    [Chain.Dogecoin]: true,
-    [Chain.Litecoin]: true,
-    [Chain.Near]: true,
-    [Chain.Optimism]: true,
-    [Chain.Polygon]: true,
-    [Chain.Ripple]: true,
-    [Chain.Sui]: true,
-    [Chain.THORChain]: true,
-    [Chain.Tron]: true,
-    [Chain.XLayer]: true,
-    // ZEC transparent transfers use DSK, but route-level PCZT signing remains unsupported.
-  },
   getExtendedPublicKey: getLedgerExtendedPublicKey,
   name: "connectLedger",
+  signingSupport: {
+    ...Object.fromEntries(LEDGER_EVM_CHAINS.map((chain) => [chain, { direct: true, typedData: true }])),
+    [Chain.Bitcoin]: { direct: true },
+    [Chain.BitcoinCash]: { direct: true },
+    [Chain.Cardano]: { direct: true },
+    [Chain.Cosmos]: { direct: true },
+    [Chain.Dash]: { direct: true },
+    [Chain.Dogecoin]: { direct: true },
+    [Chain.Litecoin]: { direct: true },
+    [Chain.Near]: { direct: true },
+    [Chain.Ripple]: { direct: true },
+    [Chain.Stellar]: { direct: true },
+    [Chain.Sui]: { direct: true },
+    [Chain.THORChain]: { direct: true },
+    [Chain.Ton]: { direct: true },
+    [Chain.Tron]: { direct: true },
+    // ZEC transparent transfers use DSK, but route-level PCZT signing remains unsupported.
+  },
   supportedChains: [...LEDGER_SUPPORTED_CHAINS_CONFIG],
   walletType: WalletOption.LEDGER,
 });
@@ -219,8 +217,8 @@ function getLedgerAccountXpub({ chain, path, signer, xpubVersion }: LedgerAccoun
     .exhaustive();
 }
 
-// Toolbox-built transactions keep input txids in display order, the order the UTXO API looks transactions up by,
-// while ZcashTransaction.fromBytes (raw API route transactions) keeps them in wire order, so try both. A txid and its
+// Txids are looked up in display order, the order the UTXO API names transactions by. utxo-signer below 3.2
+// parsed raw transactions with wire-order txids, so the reversed order is tried as a fallback. A txid and its
 // byte reversal cannot both name real transactions, so the fallback cannot fetch an unrelated one.
 function resolveZcashInputUtxos(transaction: ZcashTransaction): Promise<UTXOType[]> {
   const zcashApi = getUtxoApi(Chain.Zcash);
@@ -649,6 +647,21 @@ async function getNearWalletMethods({
   return { ...toolbox, address: accountId };
 }
 
+async function getCardanoWalletMethods({
+  chain,
+  derivationPath,
+  dmkSession,
+  onDeviceActionState,
+  transport,
+}: WalletMethodsParams<Chain.Cardano>) {
+  const { getCardanoToolbox } = await import("@swapkit/toolboxes/cardano");
+  const signer = await getLedgerClient({ chain, derivationPath, dmkSession, onDeviceActionState, transport });
+  const address = signer.getAddress();
+  const toolbox = getCardanoToolbox({ signer });
+
+  return { ...toolbox, address };
+}
+
 async function getRippleWalletMethods({
   chain,
   derivationPath,
@@ -664,6 +677,21 @@ async function getRippleWalletMethods({
   return { ...toolbox, address };
 }
 
+async function getStellarWalletMethods({
+  chain,
+  derivationPath,
+  dmkSession,
+  onDeviceActionState,
+  transport,
+}: WalletMethodsParams<Chain.Stellar>) {
+  const { getStellarToolbox } = await import("@swapkit/toolboxes/stellar");
+  const signer = await getLedgerClient({ chain, derivationPath, dmkSession, onDeviceActionState, transport });
+  const address = await getLedgerAddress({ chain, ledgerClient: signer });
+  const toolbox = getStellarToolbox({ signer });
+
+  return { ...toolbox, address };
+}
+
 async function getTronWalletMethods({
   chain,
   derivationPath,
@@ -694,6 +722,47 @@ async function getSuiWalletMethods({
   return { ...toolbox, address };
 }
 
+async function getTONWalletMethods({
+  chain,
+  derivationPath,
+  dmkSession,
+  onDeviceActionState,
+  transport,
+}: WalletMethodsParams<Chain.Ton>) {
+  const { getTONToolbox } = await import("@swapkit/toolboxes/ton");
+  const signer = await getLedgerClient({ chain, derivationPath, dmkSession, onDeviceActionState, transport });
+  const address = await getLedgerAddress({ chain, ledgerClient: signer });
+  // Signerless toolbox: it builds messages and reads balances, the device signs the external message.
+  const toolbox = getTONToolbox();
+
+  const signAndBroadcastTransaction = async (transaction: TONTransactionInput) =>
+    toolbox.broadcastTransaction(await signer.signTransaction(transaction));
+
+  const transfer = async ({ assetValue, memo, recipient, sweep }: GenericTransferParams) =>
+    signAndBroadcastTransaction(
+      await toolbox.createTransaction({ assetValue, memo, recipient, sender: address, sweep }),
+    );
+
+  // Same budget as TON Connect: the signerless toolbox underestimates jetton fees
+  const estimateTransactionFee = ({ assetValue }: GenericTransferParams) =>
+    Promise.resolve(AssetValue.from({ chain: Chain.Ton, value: assetValue.isGasAsset ? "0.01" : "0.06" }));
+
+  const sign = () => {
+    throw new SwapKitError("wallet_ledger_method_not_supported", { method: "sign", wallet: WalletOption.LEDGER });
+  };
+
+  return {
+    ...toolbox,
+    address,
+    estimateTransactionFee,
+    getAddress: () => address,
+    getBalance: () => toolbox.getBalance(address),
+    sign,
+    signAndBroadcastTransaction,
+    transfer,
+  };
+}
+
 function getWalletMethods(params: WalletMethodsParams) {
   if (!isLedgerSupportedChain(params.chain)) {
     throw new SwapKitError("wallet_ledger_chain_not_supported", { chain: params.chain });
@@ -706,8 +775,11 @@ function getWalletMethods(params: WalletMethodsParams) {
     .with(Chain.THORChain, (chain) => getTHORChainWalletMethods({ ...params, chain }))
     .with(Chain.Near, (chain) => getNearWalletMethods({ ...params, chain }))
     .with(Chain.Ripple, (chain) => getRippleWalletMethods({ ...params, chain }))
+    .with(Chain.Stellar, (chain) => getStellarWalletMethods({ ...params, chain }))
+    .with(Chain.Cardano, (chain) => getCardanoWalletMethods({ ...params, chain }))
     .with(Chain.Tron, (chain) => getTronWalletMethods({ ...params, chain }))
     .with(Chain.Sui, (chain) => getSuiWalletMethods({ ...params, chain }))
+    .with(Chain.Ton, (chain) => getTONWalletMethods({ ...params, chain }))
     .exhaustive();
 }
 

package/src/ledger/types.ts

@@ -13,6 +13,7 @@ import type {
   MonadLedger,
   OptimismLedger,
   PolygonLedger,
+  RobinhoodLedger,
   XLayerLedger,
 } from "./clients/evm";
 import type { SuiLedger } from "./clients/sui";
@@ -42,6 +43,7 @@ export type EVMLedgerClients =
   | ReturnType<typeof MonadLedger>
   | ReturnType<typeof OptimismLedger>
   | ReturnType<typeof PolygonLedger>
+  | ReturnType<typeof RobinhoodLedger>
   | ReturnType<typeof XLayerLedger>;
 export type TronLedgerClient = ReturnType<typeof TronLedger>;
 export type SuiLedgerClient = ReturnType<typeof SuiLedger>;

package/src/trezor/cardanoSigner.ts

@@ -8,13 +8,13 @@ import {
 } from "@swapkit/toolboxes/cardano";
 import type {
   CardanoAssetGroup,
-  CardanoInput,
   CardanoOutput,
   CardanoSignedTxData,
   CardanoSignTransaction,
-  PROTO,
 } from "@trezor/connect-web";
 
+import { type CardanoOutputFields, readCardanoBody } from "../helpers/cardano";
+
 type CardanoAddressParams = { address: string; path: string; stakingPath: string };
 export type TrezorConnectModule = typeof import("@trezor/connect-web");
 
@@ -26,9 +26,6 @@ function getConnectParams({ CARDANO, PROTO }: TrezorConnectModule) {
   };
 }
 
-const BODY = { AUXILIARY_DATA_HASH: 7, FEE: 2, INPUTS: 0, OUTPUTS: 1, TTL: 3, VALIDITY_INTERVAL_START: 8 } as const;
-const SET_TAG = 258;
-
 function notSupported(reason: string) {
   return new SwapKitError({ errorKey: "wallet_trezor_method_not_supported", info: { chain: Chain.Cardano, reason } });
 }
@@ -40,50 +37,12 @@ function signFailed(error: string) {
   });
 }
 
-function toUint(value: unknown, field: string) {
-  const isBigNumber = typeof value === "object" && value !== null && "toFixed" in value;
-  const text = isBigNumber || Number.isSafeInteger(value) ? String((value as number).toFixed()) : "";
-  if (!/^\d+$/.test(text)) throw notSupported(`Invalid ${field} in Cardano transaction`);
-  return text;
-}
-
-function toTokenBundle(multiAsset: Map<Uint8Array, Map<Uint8Array, unknown>>): CardanoAssetGroup[] {
-  return [...multiAsset].map(([policyId, assets]) => ({
-    policyId: hex.encode(policyId),
-    tokenAmounts: [...assets].map(([assetName, amount]) => ({
-      amount: toUint(amount, "token amount"),
-      assetNameBytes: hex.encode(assetName),
-    })),
-  }));
-}
-
 async function toTrezorOutput(
-  output: unknown,
+  { address, amount, format, tokenGroups }: CardanoOutputFields,
   own: CardanoAddressParams,
   proto: TrezorConnectModule["PROTO"],
 ): Promise<CardanoOutput> {
-  let address: unknown;
-  let value: unknown;
-  let format: PROTO.CardanoTxOutputSerializationFormat;
-
-  if (Array.isArray(output)) {
-    if (output.length !== 2) throw notSupported("Trezor cannot sign Cardano outputs with a datum");
-    [address, value] = output;
-    format = proto.CardanoTxOutputSerializationFormat.ARRAY_LEGACY;
-  } else if (output instanceof Map) {
-    if (output.has(2)) throw notSupported("Trezor cannot sign Cardano outputs with a datum");
-    if (output.has(3)) throw notSupported("Trezor cannot sign Cardano outputs with a reference script");
-    if (output.size !== 2) throw notSupported("Unsupported field in Cardano output");
-    address = output.get(0);
-    value = output.get(1);
-    format = proto.CardanoTxOutputSerializationFormat.MAP_BABBAGE;
-  } else {
-    throw notSupported("Invalid Cardano output");
-  }
-
-  if (Array.isArray(value) && value.length !== 2) throw notSupported("Invalid Cardano output value");
-  const [coin, multiAsset] = Array.isArray(value) ? value : [value];
-  const outputAddress = await getCardanoAddressFromBytes(address as Uint8Array);
+  const outputAddress = await getCardanoAddressFromBytes(address);
   const destination =
     outputAddress === own.address
       ? {
@@ -94,29 +53,22 @@ async function toTrezorOutput(
           },
         }
       : { address: outputAddress };
+  const tokenBundle: CardanoAssetGroup[] | undefined = tokenGroups?.map(({ policyId, tokens }) => ({
+    policyId: hex.encode(policyId),
+    tokenAmounts: tokens.map(({ amount, assetName }) => ({ amount, assetNameBytes: hex.encode(assetName) })),
+  }));
 
   return {
     ...destination,
-    amount: toUint(coin, "output amount"),
-    format,
-    ...(multiAsset === undefined ? {} : { tokenBundle: toTokenBundle(multiAsset) }),
+    amount,
+    format:
+      format === "legacy"
+        ? proto.CardanoTxOutputSerializationFormat.ARRAY_LEGACY
+        : proto.CardanoTxOutputSerializationFormat.MAP_BABBAGE,
+    ...(tokenBundle === undefined ? {} : { tokenBundle }),
   };
 }
 
-function toTrezorInputs(inputs: unknown, path: string) {
-  const isTagged =
-    typeof inputs === "object" && inputs !== null && "tag" in inputs && inputs.tag === SET_TAG && "value" in inputs;
-  const list = (isTagged ? inputs.value : inputs) as unknown[][];
-
-  const trezorInputs: CardanoInput[] = list.map((input) => {
-    if (input.length !== 2) throw notSupported("Invalid Cardano input");
-    const [txHash, index] = input as [Uint8Array, unknown];
-    return { path, prev_hash: hex.encode(txHash), prev_index: Number(toUint(index, "input index")) };
-  });
-
-  return { inputs: trezorInputs, tagCborSets: isTagged };
-}
-
 export async function toTrezorCardanoTransaction(
   txHex: string,
   own: CardanoAddressParams,
@@ -125,31 +77,23 @@ export async function toTrezorCardanoTransaction(
   const { body } = await decodeCardanoTransaction(txHex);
   const { derivationType, mainnet } = getConnectParams(connect);
   const { PROTO: proto } = connect;
-
-  const supportedFields: unknown[] = Object.values(BODY);
-  const unsupported = [...body.keys()].filter((field) => !supportedFields.includes(field));
-  if (unsupported.length > 0) {
-    throw notSupported(`Trezor cannot sign Cardano transactions with body fields ${unsupported.join(", ")}`);
-  }
-
-  const outputs = body.get(BODY.OUTPUTS) as unknown[];
-  const auxiliaryDataHash = body.get(BODY.AUXILIARY_DATA_HASH) as Uint8Array | undefined;
-
-  const ttl = body.get(BODY.TTL);
-  const validityIntervalStart = body.get(BODY.VALIDITY_INTERVAL_START);
+  const { auxiliaryDataHash, fee, inputs, outputs, tagCborSets, ttl, validityIntervalStart } = readCardanoBody(
+    body,
+    "Trezor",
+    notSupported,
+  );
 
   return {
-    ...toTrezorInputs(body.get(BODY.INPUTS), own.path),
+    inputs: inputs.map(({ index, txHash }) => ({ path: own.path, prev_hash: hex.encode(txHash), prev_index: index })),
+    tagCborSets,
     ...mainnet,
     derivationType,
-    fee: toUint(body.get(BODY.FEE), "fee"),
+    fee,
     outputs: await Promise.all(outputs.map((output) => toTrezorOutput(output, own, proto))),
     signingMode: proto.CardanoTxSigningMode.ORDINARY_TRANSACTION,
     ...(auxiliaryDataHash ? { auxiliaryData: { hash: hex.encode(auxiliaryDataHash) } } : {}),
-    ...(ttl === undefined ? {} : { ttl: toUint(ttl, "ttl") }),
-    ...(validityIntervalStart === undefined
-      ? {}
-      : { validityIntervalStart: toUint(validityIntervalStart, "validity interval start") }),
+    ...(ttl === undefined ? {} : { ttl }),
+    ...(validityIntervalStart === undefined ? {} : { validityIntervalStart }),
   };
 }
 

package/src/trezor/hypercoreSigner.ts

@@ -0,0 +1,96 @@
+import { Chain, type DerivationPathArray, derivationPathToString, SwapKitError } from "@swapkit/helpers";
+import type { TypedDataDomain, TypedDataField } from "ethers";
+
+type TypedDataTypes = Record<string, TypedDataField[]>;
+type TypedDataValue = Record<string, unknown>;
+
+function notSupported(reason: string) {
+  return new SwapKitError({ errorKey: "wallet_trezor_method_not_supported", info: { chain: Chain.Hype, reason } });
+}
+
+export async function toTrezorHyperCoreTypedData(
+  domain: TypedDataDomain,
+  types: TypedDataTypes,
+  message: TypedDataValue,
+) {
+  const { TypedDataEncoder } = await import("ethers");
+  const { EIP712Domain: _, ...structTypes } = types;
+
+  try {
+    // ethers checks the domain, the type graph and every value; the device still gets the caller's own data
+    const payload: { primaryType: string; types: TypedDataTypes } = TypedDataEncoder.getPayload(
+      domain,
+      structTypes,
+      message,
+    );
+    return {
+      domain,
+      message,
+      primaryType: payload.primaryType,
+      types: { EIP712Domain: payload.types.EIP712Domain, ...structTypes },
+    };
+  } catch (error) {
+    throw notSupported(`Invalid HyperCore typed data: ${(error as Error).message}`);
+  }
+}
+
+export function getHyperCoreSigner({
+  address: knownAddress,
+  derivationPath,
+}: {
+  address?: string;
+  derivationPath: DerivationPathArray;
+}) {
+  const path = derivationPathToString(derivationPath);
+  let address = knownAddress ?? "";
+
+  return {
+    getAddress: async () => {
+      if (address) return address;
+
+      const TrezorConnect = (await import("@trezor/connect-web")).default;
+      const result = await TrezorConnect.ethereumGetAddress({ path, showOnTrezor: true });
+
+      if (!result.success) {
+        throw new SwapKitError({
+          errorKey: "wallet_trezor_failed_to_get_address",
+          info: { chain: Chain.Hype, derivationPath, error: result.payload.error },
+        });
+      }
+
+      address = result.payload.address;
+      return address;
+    },
+
+    // HyperCore has no transactions: every action goes through signTypedData
+    signTransaction: () => Promise.reject(notSupported("HyperCore actions are signed with signTypedData")),
+
+    signTypedData: async (domain: TypedDataDomain, types: TypedDataTypes, message: TypedDataValue) => {
+      const data = await toTrezorHyperCoreTypedData(domain, types, message);
+      const TrezorConnect = (await import("@trezor/connect-web")).default;
+
+      const result = await TrezorConnect.ethereumSignTypedData({
+        data: data as Parameters<typeof TrezorConnect.ethereumSignTypedData>[0]["data"],
+        metamask_v4_compat: true,
+        path,
+      });
+
+      if (!result.success) {
+        throw new SwapKitError({
+          errorKey: "wallet_trezor_failed_to_sign_transaction",
+          info: { chain: Chain.Hype, error: result.payload.error },
+        });
+      }
+
+      // Hyperliquid takes the account from the signature, so a stale known address would act from another account
+      if (result.payload.address.toLowerCase() !== address.toLowerCase()) {
+        throw new SwapKitError({
+          errorKey: "wallet_trezor_failed_to_sign_transaction",
+          info: { chain: Chain.Hype, error: "Trezor signed with a different address", signer: result.payload.address },
+        });
+      }
+
+      return result.payload.signature.startsWith("0x") ? result.payload.signature : `0x${result.payload.signature}`;
+    },
+  };
+}