@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/api/ethereum/api/ethereumSignMessage.mjs

@@ -0,0 +1,64 @@
+import { EthereumSignMessage as EthereumSignMessageSchema } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
+import { getEthereumNetwork } from "../../../data/coinInfo.mjs";
+import { validateModelOneMessageSize } from "../../../device/validateMessageSize.mjs";
+import { getNetworkLabel } from "../../../utils/ethereumUtils.mjs";
+import { hexToText, messageToHex } from "../../../utils/formatUtils.mjs";
+import { getSerializedPath, getSlip44ByPath, validatePath } from "../../../utils/pathUtils.mjs";
+import { getEthereumDefinitions } from "../ethereumDefinitions.mjs";
+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 ['read', 'write'];
+  }
+  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/libESM/api/ethereum/api/ethereumSignTransaction.d.mts

@@ -0,0 +1,83 @@
+import type { EthereumNetworkInfoDefinitionValues, EthereumTransaction, EthereumTransactionEIP1559, MethodPermission, TokenInfo } from '@trezor/connect-common';
+import type { MessagesSchema } from '@trezor/protobuf';
+import type { MethodMessage } from '../../../core/AbstractMethod';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+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(): MethodPermission[];
+    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: string;
+        v: `0x${string}`;
+        r: `0x${string}`;
+        s: `0x${string}`;
+    }>;
+}
+export {};

package/libESM/api/ethereum/api/ethereumSignTransaction.mjs

@@ -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.mjs";
+import { getEthereumNetwork } from "../../../data/coinInfo.mjs";
+import { getNetworkLabel } from "../../../utils/ethereumUtils.mjs";
+import { deepTransform, stripHexPrefix } from "../../../utils/formatUtils.mjs";
+import { getSlip44ByPath, validatePath } from "../../../utils/pathUtils.mjs";
+import { PAYMENT_REQUEST_AMOUNT_BYTES, encodePaymentRequestAmount } from "../../../utils/paymentRequest.mjs";
+import { decodeEthereumDefinition, ethereumNetworkInfoFromDefinition, getEthereumDefinitions } from "../ethereumDefinitions.mjs";
+import * as helper from "../ethereumSignTx.mjs";
+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 ['read', 'write'];
+  }
+  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/libESM/api/ethereum/api/ethereumSignTypedData.d.mts

@@ -0,0 +1,116 @@
+import { EthereumNetworkInfo, EthereumSignTypedData as EthereumSignTypedDataParams, EthereumSignTypedHash as EthereumSignTypedHashParams } from '@trezor/connect-common';
+import type { EthereumSignTypedDataTypes, MethodPermission } from '@trezor/connect-common';
+import { MessagesSchema } from '@trezor/protobuf';
+import type { MethodMessage } from '../../../core/AbstractMethod';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+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/libESM/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/libESM/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/libESM/custom-types/array-buffer").TArrayBuffer>;
+        encoded_token: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils/libESM/custom-types/array-buffer").TArrayBuffer>;
+    }>>;
+}>]>;
+export default class EthereumSignTypedData extends AbstractMethod<'ethereumSignTypedData', Params> {
+    constructor(message: MethodMessage<'ethereumSignTypedData'>);
+    get requiredPermissions(): MethodPermission[];
+    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/libESM/api/ethereum/api/ethereumSignTypedData.mjs

@@ -0,0 +1,202 @@
+import { EthereumNetworkInfo, EthereumSignTypedData as EthereumSignTypedDataParams, EthereumSignTypedHash as EthereumSignTypedHashParams } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { DeviceModelInternal } from "@trezor/device-utils";
+import { MessagesSchema } from "@trezor/protobuf";
+import { Assert, Type } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
+import { getEthereumNetwork } from "../../../data/coinInfo.mjs";
+import { getNetworkLabel } from "../../../utils/ethereumUtils.mjs";
+import { messageToHex } from "../../../utils/formatUtils.mjs";
+import { getSerializedPath, getSlip44ByPath, validatePath } from "../../../utils/pathUtils.mjs";
+import { getEthereumDefinitions } from "../ethereumDefinitions.mjs";
+import { encodeData, getFieldType, parseArrayType, transformTypedData } from "../ethereumSignTypedData.mjs";
+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 ['read', 'write'];
+  }
+  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 memberTypeDefinition = types[memberTypeName][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/libESM/api/ethereum/api/ethereumVerifyMessage.d.mts

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

package/libESM/api/ethereum/api/ethereumVerifyMessage.mjs

@@ -0,0 +1,33 @@
+import { EthereumVerifyMessage as EthereumVerifyMessageSchema } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
+import { validateModelOneMessageSize } from "../../../device/validateMessageSize.mjs";
+import { messageToHex, stripHexPrefix } from "../../../utils/formatUtils.mjs";
+export default class EthereumVerifyMessage extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(EthereumVerifyMessageSchema, payload);
+    const messageHex = payload.hex ? messageToHex(payload.message) : Buffer.from(payload.message, 'utf8').toString('hex');
+    const params = {
+      address: stripHexPrefix(payload.address),
+      signature: stripHexPrefix(payload.signature),
+      message: messageHex
+    };
+    super(message, params);
+    this.requiredDeviceCapabilities = ['Capability_Ethereum'];
+  }
+  get requiredPermissions() {
+    return ['read'];
+  }
+  get info() {
+    return 'Verify message';
+  }
+  async run() {
+    validateModelOneMessageSize(this.getDevice(), this.params.message);
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('EthereumVerifyMessage', 'Success', this.params);
+    return response.message;
+  }
+}

package/libESM/api/ethereum/api/index.d.mts

@@ -0,0 +1,6 @@
+export { default as ethereumGetAddress } from './ethereumGetAddress';
+export { default as ethereumGetPublicKey } from './ethereumGetPublicKey';
+export { default as ethereumSignMessage } from './ethereumSignMessage';
+export { default as ethereumSignTransaction } from './ethereumSignTransaction';
+export { default as ethereumSignTypedData } from './ethereumSignTypedData';
+export { default as ethereumVerifyMessage } from './ethereumVerifyMessage';