@trezor/connect 10.0.0-alpha.1 → 10.0.0-beta.1

package/lib/api/ethereum/api/ethereumSignMessage.d.ts

@@ -0,0 +1,27 @@
+import type { EthereumNetworkInfo, PermissionRequest } from '@trezor/connect-common';
+import type { MessagesSchema, MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+type Params = {
+  proto: PROTO.EthereumSignMessage;
+  readableMessage: string;
+  network?: EthereumNetworkInfo;
+  definitions?: MessagesSchema.EthereumDefinitions;
+};
+export default class EthereumSignMessage extends AbstractMethod<'ethereumSignMessage', Params> {
+  constructor(message: MethodMessage<'ethereumSignMessage'>);
+  get requiredPermissions(): PermissionRequest[];
+  initAsync(): Promise<void>;
+  get info(): string;
+  getButtonRequestData(code: string, name?: string): {
+    type: "message";
+    coin: string;
+    serializedPath: string;
+    message: string;
+  } | undefined;
+  run(): Promise<{
+    address: string;
+    signature: string;
+  }>;
+}
+export {};

package/lib/api/ethereum/api/ethereumSignMessage.js

@@ -0,0 +1,64 @@
+import { EthereumSignMessage as EthereumSignMessageSchema } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getEthereumNetwork } from "../../../data/coinInfo.js";
+import { validateModelOneMessageSize } from "../../../device/validateMessageSize.js";
+import { getNetworkLabel } from "../../../utils/ethereumUtils.js";
+import { hexToText, messageToHex } from "../../../utils/formatUtils.js";
+import { getSerializedPath, getSlip44ByPath, validatePath } from "../../../utils/pathUtils.js";
+import { getEthereumDefinitions } from "../ethereumDefinitions.js";
+export default class EthereumSignMessage extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(EthereumSignMessageSchema, payload);
+    const address_n = validatePath(payload.path, 3);
+    const network = getEthereumNetwork(address_n);
+    const messageHex = payload.hex ? messageToHex(payload.message) : Buffer.from(payload.message, 'utf8').toString('hex');
+    const readableMessage = payload.hex ? hexToText(payload.message) : payload.message;
+    const params = {
+      proto: {
+        address_n,
+        message: messageHex
+      },
+      readableMessage
+    };
+    super(message, params);
+    this.requiredFirmwareCoins = [network];
+    this.requiredDeviceCapabilities = ['Capability_Ethereum'];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('sign', this.requiredFirmwareCoins);
+  }
+  async initAsync() {
+    if (this.params.network) return;
+    const {
+      address_n
+    } = this.params.proto;
+    const slip44 = getSlip44ByPath(address_n);
+    const definitions = await getEthereumDefinitions({
+      slip44
+    });
+    this.params.proto.encoded_network = definitions.encoded_network;
+  }
+  get info() {
+    return getNetworkLabel('Sign #NETWORK message', getEthereumNetwork(this.params.proto.address_n));
+  }
+  getButtonRequestData(code, name) {
+    if (code === 'ButtonRequest_Other' && name === 'sign_message') {
+      return {
+        type: 'message',
+        coin: this.params.network?.shortcut ?? 'ETH',
+        serializedPath: getSerializedPath(this.params.proto.address_n),
+        message: this.params.readableMessage
+      };
+    }
+  }
+  async run() {
+    validateModelOneMessageSize(this.getDevice(), this.params.proto.message);
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('EthereumSignMessage', 'EthereumMessageSignature', this.params.proto);
+    return response.message;
+  }
+}

package/lib/api/ethereum/api/ethereumSignTransaction.d.ts

@@ -0,0 +1,83 @@
+import type { EthereumNetworkInfoDefinitionValues, EthereumTransaction, EthereumTransactionEIP1559, PermissionRequest, TokenInfo } from '@trezor/connect-common';
+import type { MessagesSchema } from '@trezor/protobuf';
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+type Params = {
+  path: number[];
+  network?: EthereumNetworkInfoDefinitionValues;
+  definitions?: MessagesSchema.EthereumDefinitions;
+  chunkify: boolean;
+} & ({
+  type: 'legacy';
+  tx: EthereumTransaction;
+  originalTx: EthereumTransaction;
+} | {
+  type: 'eip1559';
+  tx: EthereumTransactionEIP1559;
+  originalTx: EthereumTransactionEIP1559;
+});
+export default class EthereumSignTransaction extends AbstractMethod<'ethereumSignTransaction', Params> {
+  constructor(message: MethodMessage<'ethereumSignTransaction'>);
+  get requiredPermissions(): PermissionRequest[];
+  initAsync(): Promise<void>;
+  get info(): string;
+  payloadToPrecomposed(): Promise<undefined> | Promise<{
+    type: "final";
+    inputs: never[];
+    outputsPermutation: number[];
+    outputs: {
+      address: string;
+      amount: string;
+      script_type: "PAYTOADDRESS";
+    }[];
+    totalSpent: string;
+    fee: string;
+    feePerByte: string;
+    maxFeePerGas: string | undefined;
+    maxPriorityFeePerGas: string | undefined;
+    feeLimit: string;
+    bytes: number;
+    max: undefined;
+    isTokenKnown: boolean;
+    token: TokenInfo | undefined;
+    nativeToken: {
+      type: string;
+      standard: string;
+      contract: string;
+      name: string;
+      symbol: string;
+      decimals: number;
+    } | undefined;
+    network: ({
+      blockchainLink?: {
+        type: string;
+        url: string[];
+      } | undefined;
+      label: string;
+      name: string;
+      shortcut: string;
+      slip44: number;
+      support: {
+        T1B1: string | false;
+        T2T1: string | false;
+        T3T1: string | false;
+        T2B1: string | false;
+        T3B1: string | false;
+        T3W1: string | false;
+        UNKNOWN: string | false;
+      };
+      decimals: number;
+    } & {
+      network?: undefined;
+      type: "ethereum";
+      chainId: number;
+    }) | undefined;
+  }>;
+  run(): Promise<{
+    serializedTx: `0x02${string}` | import("viem").TransactionSerializedLegacy;
+    v: `0x${string}`;
+    r: `0x${string}`;
+    s: `0x${string}`;
+  }>;
+}
+export {};

package/lib/api/ethereum/api/ethereumSignTransaction.js

@@ -0,0 +1,148 @@
+import { EthereumSignTransaction as EthereumSignTransactionSchema } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { BigNumber } from "@trezor/utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getEthereumNetwork } from "../../../data/coinInfo.js";
+import { getNetworkLabel } from "../../../utils/ethereumUtils.js";
+import { deepTransform, stripHexPrefix } from "../../../utils/formatUtils.js";
+import { getSlip44ByPath, validatePath } from "../../../utils/pathUtils.js";
+import { PAYMENT_REQUEST_AMOUNT_BYTES, encodePaymentRequestAmount } from "../../../utils/paymentRequest.js";
+import { decodeEthereumDefinition, ethereumNetworkInfoFromDefinition, getEthereumDefinitions } from "../ethereumDefinitions.js";
+import * as helper from "../ethereumSignTx.js";
+const strip = deepTransform(value => {
+  let stripped = stripHexPrefix(value);
+  if (stripped.length % 2 !== 0) {
+    stripped = `0${stripped}`;
+  }
+  return stripped;
+});
+export default class EthereumSignTransaction extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(EthereumSignTransactionSchema, payload);
+    const path = validatePath(payload.path, 3);
+    const network = getEthereumNetwork(path);
+    const chunkify = typeof payload.chunkify === 'boolean' ? payload.chunkify : false;
+    const tx = payload.transaction;
+    const isEIP1559 = typeof tx.maxFeePerGas === 'string' && typeof tx.maxPriorityFeePerGas === 'string';
+    const params = {
+      path,
+      network,
+      type: isEIP1559 ? 'eip1559' : 'legacy',
+      tx: {
+        ...strip(tx),
+        payment_req: tx.payment_req ? encodePaymentRequestAmount(tx.payment_req, PAYMENT_REQUEST_AMOUNT_BYTES.EVM) : undefined
+      },
+      originalTx: tx,
+      chunkify
+    };
+    if (typeof tx.chainId !== 'number') {
+      console.warn('TrezorConnect.ethereumSignTransaction: Missing chainId parameter!');
+    }
+    super(message, params);
+    this.requiredFirmwareCoins = [network];
+    this.requiredDeviceCapabilities = ['Capability_Ethereum'];
+    if (isEIP1559) {
+      this.requiredFirmwareCapabilities = ['eip1559'];
+    }
+  }
+  get requiredPermissions() {
+    return this.coinPerms('sign', this.requiredFirmwareCoins);
+  }
+  async initAsync() {
+    if (this.params.tx.chainId === 1 && !this.params.tx.data) {
+      return;
+    }
+    const slip44 = getSlip44ByPath(this.params.path);
+    const definitions = await getEthereumDefinitions({
+      chainId: this.params.tx.chainId,
+      slip44,
+      contractAddress: this.params.tx.data && this.params.tx.to != null ? this.params.tx.to : undefined
+    });
+    this.params.definitions = definitions;
+    const decoded = decodeEthereumDefinition(definitions);
+    if (decoded.network) {
+      this.params.network = ethereumNetworkInfoFromDefinition(decoded.network);
+    }
+  }
+  get info() {
+    return getNetworkLabel('Sign #NETWORK transaction', this.params.network);
+  }
+  payloadToPrecomposed() {
+    try {
+      const transaction = this.params.originalTx;
+      const feePerByte = new BigNumber(transaction.gasPrice || transaction.maxFeePerGas);
+      const fee = feePerByte.multipliedBy(transaction.gasLimit);
+      const {
+        data
+      } = transaction;
+      let recipient = transaction.to;
+      let amount = new BigNumber(transaction.value);
+      let totalSpent = amount.plus(fee);
+      let token;
+      if (transaction.to && data?.startsWith('a9059cbb') && amount.eq(0) && this.params.definitions) {
+        const decoded = decodeEthereumDefinition(this.params.definitions);
+        if (decoded.token) {
+          recipient = '0x' + data.slice(32, 72);
+          amount = new BigNumber(data.slice(72, 136), 16);
+          totalSpent = amount;
+          token = {
+            ...decoded.token,
+            standard: 'ERC20',
+            contract: decoded.token.address
+          };
+        }
+      }
+      const result = {
+        type: 'final',
+        inputs: [],
+        outputsPermutation: [0],
+        outputs: [{
+          address: recipient,
+          amount: amount.toString(),
+          script_type: 'PAYTOADDRESS'
+        }],
+        totalSpent: totalSpent.toString(),
+        fee: fee.toString(),
+        feePerByte: feePerByte.dividedBy(1e9).toString(),
+        maxFeePerGas: transaction.maxFeePerGas ? new BigNumber(transaction.maxFeePerGas).dividedBy(1e9).toString() : undefined,
+        maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? new BigNumber(transaction.maxPriorityFeePerGas).dividedBy(1e9).toString() : undefined,
+        feeLimit: new BigNumber(transaction.gasLimit).toString(),
+        bytes: 0,
+        max: undefined,
+        isTokenKnown: !!token,
+        token,
+        nativeToken: this.params.network ? {
+          type: 'NATIVE',
+          standard: 'NATIVE',
+          contract: '',
+          name: this.params.network.name,
+          symbol: this.params.network.shortcut,
+          decimals: this.params.network.decimals
+        } : undefined,
+        network: this.params.network
+      };
+      return Promise.resolve(result);
+    } catch (e) {
+      console.error('Error in payloadToPrecomposed', e);
+      return Promise.resolve(undefined);
+    }
+  }
+  async run() {
+    const {
+      type,
+      tx,
+      definitions,
+      chunkify
+    } = this.params;
+    const isLegacy = type === 'legacy';
+    const signature = isLegacy ? await helper.ethereumSignTx(this.getDevice().getCommands().typedCall, this.params.path, tx.to, tx.value, tx.gasLimit, tx.gasPrice, tx.nonce, tx.chainId, chunkify, tx.data, tx.txType, definitions, tx.payment_req) : await helper.ethereumSignTxEIP1559(this.getDevice().getCommands().typedCall, this.params.path, tx.to, tx.value, tx.gasLimit, tx.maxFeePerGas, tx.maxPriorityFeePerGas, tx.nonce, tx.chainId, chunkify, tx.data, tx.accessList, definitions, tx.payment_req);
+    const serializedTx = helper.serializeEthereumTx(tx, signature, isLegacy);
+    return {
+      ...signature,
+      serializedTx
+    };
+  }
+}

package/lib/api/ethereum/api/ethereumSignTypedData.d.ts

@@ -0,0 +1,117 @@
+import { EthereumNetworkInfo, EthereumSignTypedData as EthereumSignTypedDataParams, EthereumSignTypedHash as EthereumSignTypedHashParams } from '@trezor/connect-common';
+import type { EthereumSignTypedDataTypes, PermissionRequest } from '@trezor/connect-common';
+import { MessagesSchema } from '@trezor/protobuf';
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+type Params = (Omit<EthereumSignTypedDataParams<EthereumSignTypedDataTypes>, 'path'> | Omit<EthereumSignTypedHashParams<EthereumSignTypedDataTypes>, 'path'>) & {
+  address_n: number[];
+  network?: EthereumNetworkInfo;
+  definitions?: MessagesSchema.EthereumDefinitions;
+};
+declare const Params: import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+  data: import("@sinclair/typebox").TObject<{
+    types: import("@sinclair/typebox").TObject<{
+      EIP712Domain: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TString;
+        type: import("@sinclair/typebox").TString;
+      }>>;
+    }>;
+    primaryType: import("@sinclair/typebox").TString;
+    domain: import("@sinclair/typebox").TObject<{
+      name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+      version: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+      chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TBigInt, import("@sinclair/typebox").TString]>>;
+      verifyingContract: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+      salt: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@trezor/schema-utils/lib/custom-types/array-buffer").TArrayBuffer, import("@sinclair/typebox").TString]>>;
+    }>;
+    message: import("@sinclair/typebox").TObject<{}>;
+  }>;
+  domain_separator_hash: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+  message_hash: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+  metamask_v4_compat: import("@sinclair/typebox").TBoolean;
+  show_message_hash: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>, import("@sinclair/typebox").TObject<{
+  data: import("@sinclair/typebox").TObject<{
+    types: import("@sinclair/typebox").TObject<{
+      EIP712Domain: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TString;
+        type: import("@sinclair/typebox").TString;
+      }>>;
+    }>;
+    primaryType: import("@sinclair/typebox").TString;
+    domain: import("@sinclair/typebox").TObject<{
+      name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+      version: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+      chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TBigInt, import("@sinclair/typebox").TString]>>;
+      verifyingContract: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+      salt: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@trezor/schema-utils/lib/custom-types/array-buffer").TArrayBuffer, import("@sinclair/typebox").TString]>>;
+    }>;
+    message: import("@sinclair/typebox").TObject<{}>;
+  }>;
+  domain_separator_hash: import("@sinclair/typebox").TString;
+  message_hash: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+  metamask_v4_compat: import("@sinclair/typebox").TBoolean;
+  show_message_hash: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>]>, import("@sinclair/typebox").TObject<{
+  address_n: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>;
+  network: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TObject<{
+    label: import("@sinclair/typebox").TString;
+    name: import("@sinclair/typebox").TString;
+    shortcut: import("@sinclair/typebox").TString;
+    slip44: import("@sinclair/typebox").TNumber;
+    support: import("@sinclair/typebox").TObject<{
+      T1B1: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TLiteral<false>]>;
+      T2T1: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TLiteral<false>]>;
+      T2B1: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TLiteral<false>]>;
+      T3B1: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TLiteral<false>]>;
+      T3T1: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TLiteral<false>]>;
+      T3W1: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TLiteral<false>]>;
+      UNKNOWN: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TLiteral<false>]>;
+    }>;
+    decimals: import("@sinclair/typebox").TNumber;
+    blockchainLink: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+      type: import("@sinclair/typebox").TString;
+      url: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    }>>;
+    blockTime: import("@sinclair/typebox").TNumber;
+    minFee: import("@sinclair/typebox").TNumber;
+    maxFee: import("@sinclair/typebox").TNumber;
+    minPriorityFee: import("@sinclair/typebox").TNumber;
+    defaultFees: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+      label: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"high">, import("@sinclair/typebox").TLiteral<"normal">, import("@sinclair/typebox").TLiteral<"economy">, import("@sinclair/typebox").TLiteral<"low">, import("@sinclair/typebox").TLiteral<"custom">]>;
+      blocks: import("@sinclair/typebox").TNumber;
+      feePerUnit: import("@sinclair/typebox").TString;
+      feePerTx: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+      feeLimit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+      baseFeePerGas: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+      maxFeePerGas: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+      maxPriorityFeePerGas: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>>;
+  }>, import("@sinclair/typebox").TObject<{
+    type: import("@sinclair/typebox").TLiteral<"ethereum">;
+    chainId: import("@sinclair/typebox").TNumber;
+    network: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+  }>]>>;
+  definitions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+    encoded_network: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils/lib/custom-types/array-buffer").TArrayBuffer>;
+    encoded_token: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils/lib/custom-types/array-buffer").TArrayBuffer>;
+    encoded_display_format: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+  }>>;
+}>]>;
+export default class EthereumSignTypedData extends AbstractMethod<'ethereumSignTypedData', Params> {
+  constructor(message: MethodMessage<'ethereumSignTypedData'>);
+  get requiredPermissions(): PermissionRequest[];
+  initAsync(): Promise<void>;
+  get info(): string;
+  getButtonRequestData(code: string, name?: string): {
+    type: "message";
+    coin: string;
+    serializedPath: string;
+    message: string;
+  } | undefined;
+  run(): Promise<{
+    address: string;
+    signature: string;
+  }>;
+}
+export {};

package/lib/api/ethereum/api/ethereumSignTypedData.js

@@ -0,0 +1,203 @@
+import { EthereumNetworkInfo, EthereumSignTypedData as EthereumSignTypedDataParams, EthereumSignTypedHash as EthereumSignTypedHashParams } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { DeviceModelInternal } from "@trezor/device-utils";
+import { MessagesSchema } from "@trezor/protobuf";
+import { Assert, Type } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getEthereumNetwork } from "../../../data/coinInfo.js";
+import { getNetworkLabel } from "../../../utils/ethereumUtils.js";
+import { messageToHex } from "../../../utils/formatUtils.js";
+import { getSerializedPath, getSlip44ByPath, validatePath } from "../../../utils/pathUtils.js";
+import { getEthereumDefinitions } from "../ethereumDefinitions.js";
+import { encodeData, getFieldType, parseArrayType, transformTypedData } from "../ethereumSignTypedData.js";
+const Params = Type.Intersect([Type.Union([Type.Omit(EthereumSignTypedDataParams, Type.Literal('path')), Type.Omit(EthereumSignTypedHashParams, Type.Literal('path'))]), Type.Object({
+  address_n: Type.Array(Type.Number()),
+  network: Type.Optional(EthereumNetworkInfo),
+  definitions: Type.Optional(MessagesSchema.EthereumDefinitions)
+})]);
+export default class EthereumSignTypedData extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(Type.Union([EthereumSignTypedDataParams, EthereumSignTypedHashParams]), payload);
+    const path = validatePath(payload.path, 3);
+    const network = getEthereumNetwork(path);
+    const isDomainOnly = payload.data?.primaryType === 'EIP712Domain';
+    const needsAutoCompute = isDomainOnly ? !payload.domain_separator_hash : !payload.domain_separator_hash || !payload.message_hash;
+    const autoHashes = needsAutoCompute && payload.data && payload.metamask_v4_compat === true ? transformTypedData(payload.data, payload.metamask_v4_compat) : undefined;
+    const effectiveDomainHash = payload.domain_separator_hash ?? autoHashes?.domain_separator_hash;
+    const effectiveMessageHash = payload.message_hash ?? (autoHashes?.message_hash ? autoHashes.message_hash : undefined);
+    const paramsBase = {
+      address_n: path,
+      metamask_v4_compat: payload.metamask_v4_compat,
+      data: payload.data,
+      network,
+      show_message_hash: payload.show_message_hash ?? payload.data.primaryType === 'SafeTx'
+    };
+    const params = !effectiveDomainHash ? paramsBase : {
+      ...paramsBase,
+      domain_separator_hash: messageToHex(effectiveDomainHash),
+      ...(effectiveMessageHash ? {
+        message_hash: messageToHex(effectiveMessageHash)
+      } : {})
+    };
+    if (payload.data.primaryType === 'EIP712Domain' && 'message_hash' in params) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'message_hash should be empty when data.primaryType=EIP712Domain');
+    }
+    if (payload.data.primaryType !== 'EIP712Domain' && !('message_hash' in params) && 'domain_separator_hash' in params) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'message_hash should only be empty when data.primaryType=EIP712Domain');
+    }
+    super(message, params);
+    this.requiredDeviceCapabilities = ['Capability_Ethereum'];
+    this.requiredFirmwareCoins = [network];
+    if (params.data.primaryType === 'EIP712Domain') {
+      this.requiredFirmwareCapabilities = ['eip712-domain-only'];
+    }
+  }
+  get requiredPermissions() {
+    return this.coinPerms('sign', this.requiredFirmwareCoins);
+  }
+  async initAsync() {
+    if (this.params.network) return;
+    const {
+      address_n
+    } = this.params;
+    const slip44 = getSlip44ByPath(address_n);
+    this.params.definitions = await getEthereumDefinitions({
+      slip44
+    });
+  }
+  get info() {
+    return getNetworkLabel('Sign #NETWORK typed data', getEthereumNetwork(this.params.address_n));
+  }
+  getButtonRequestData(code, name) {
+    if (code === 'ButtonRequest_Other' && name && ['should_show_domain', 'should_show_struct', 'should_show_array', 'confirm_typed_value', 'confirm_message_hash', 'confirm_empty_typed_message', 'confirm_typed_data_final'].includes(name) || code === 'ButtonRequest_SignTx') {
+      return {
+        type: 'message',
+        coin: this.params.network?.shortcut ?? 'ETH',
+        serializedPath: getSerializedPath(this.params.address_n),
+        message: JSON.stringify(this.params.data, null, 2)
+      };
+    }
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    const {
+      address_n,
+      definitions
+    } = this.params;
+    if (this.getDevice().features.internal_model === DeviceModelInternal.T1B1) {
+      Assert(Type.Object({
+        domain_separator_hash: Type.String(),
+        message_hash: Type.Optional(Type.String())
+      }), this.params);
+      const {
+        domain_separator_hash,
+        message_hash
+      } = this.params;
+      const response = await cmd.typedCall('EthereumSignTypedHash', 'EthereumTypedDataSignature', {
+        address_n,
+        domain_separator_hash,
+        message_hash,
+        encoded_network: definitions?.encoded_network
+      });
+      const {
+        address,
+        signature
+      } = response.message;
+      return {
+        address,
+        signature: `0x${signature}`
+      };
+    }
+    const {
+      data,
+      metamask_v4_compat
+    } = this.params;
+    const {
+      types,
+      primaryType,
+      domain,
+      message
+    } = data;
+    let response = await cmd.typedCall('EthereumSignTypedData', ['EthereumTypedDataStructRequest', 'EthereumTypedDataValueRequest', 'EthereumTypedDataSignature'], {
+      address_n,
+      primary_type: primaryType,
+      metamask_v4_compat,
+      definitions,
+      show_message_hash: this.params.show_message_hash ? this.params.message_hash : undefined
+    });
+    while (response.type === 'EthereumTypedDataStructRequest') {
+      const {
+        name: typeDefinitionName
+      } = response.message;
+      const typeDefinition = types[typeDefinitionName];
+      if (typeDefinition === undefined) {
+        throw ERRORS.TypedError('Runtime', `Type ${typeDefinitionName} was not defined in types object`);
+      }
+      const dataStruckAck = {
+        members: typeDefinition.map(({
+          name,
+          type: typeName
+        }) => ({
+          name,
+          type: getFieldType(typeName, types)
+        }))
+      };
+      response = await cmd.typedCall('EthereumTypedDataStructAck', ['EthereumTypedDataStructRequest', 'EthereumTypedDataValueRequest', 'EthereumTypedDataSignature'], dataStruckAck);
+    }
+    while (response.type === 'EthereumTypedDataValueRequest') {
+      const {
+        member_path
+      } = response.message;
+      let memberData;
+      let memberTypeName;
+      const [rootIndex, ...nestedMemberPath] = member_path;
+      switch (rootIndex) {
+        case 0:
+          memberData = domain;
+          memberTypeName = 'EIP712Domain';
+          break;
+        case 1:
+          memberData = message;
+          memberTypeName = primaryType;
+          break;
+        default:
+          throw ERRORS.TypedError('Runtime', 'Root index can only be 0 or 1');
+      }
+      for (const index of nestedMemberPath) {
+        if (Array.isArray(memberData)) {
+          memberTypeName = parseArrayType(memberTypeName).entryTypeName;
+          memberData = memberData[index];
+        } else if (typeof memberData === 'object' && memberData !== null) {
+          const memberTypeArr = types[memberTypeName];
+          const memberTypeDefinition = memberTypeArr[index];
+          memberTypeName = memberTypeDefinition.type;
+          memberData = memberData[memberTypeDefinition.name];
+        }
+        if (memberData === null || memberData === undefined) {
+          this.getDevice().getCurrentSession().cancelCall();
+          throw ERRORS.TypedError('Runtime', `Value from member path ${member_path} is missing in the data object`);
+        }
+      }
+      let encodedData;
+      if (Array.isArray(memberData)) {
+        encodedData = encodeData('uint16', memberData.length);
+      } else {
+        encodedData = encodeData(memberTypeName, memberData);
+      }
+      response = await cmd.typedCall('EthereumTypedDataValueAck', ['EthereumTypedDataValueRequest', 'EthereumTypedDataSignature'], {
+        value: encodedData
+      });
+    }
+    const {
+      address,
+      signature
+    } = response.message;
+    return {
+      address,
+      signature: `0x${signature}`
+    };
+  }
+}

package/lib/api/ethereum/api/ethereumVerifyMessage.d.ts

@@ -0,0 +1,12 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+export default class EthereumVerifyMessage extends AbstractMethod<'ethereumVerifyMessage', PROTO.EthereumVerifyMessage> {
+  constructor(message: MethodMessage<'ethereumVerifyMessage'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<{
+    message: string;
+  }>;
+}