@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/ethereum/ethereumDefinitions.js

@@ -1,32 +1,40 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ethereumNetworkInfoFromDefinition = exports.decodeEthereumDefinition = exports.EthereumDefinitionDecoded = exports.EthereumTokenDefinitionDecoded = exports.EthereumNetworkDefinitionDecoded = exports.getEthereumDefinitions = void 0;
-const tslib_1 = require("tslib");
-const cross_fetch_1 = tslib_1.__importDefault(require("cross-fetch"));
-const protobuf_1 = require("@trezor/protobuf");
-const protocol_1 = require("@trezor/protocol");
-const schema_utils_1 = require("@trezor/schema-utils");
-const DataManager_1 = require("../../data/DataManager");
-const coinInfo_1 = require("../../data/coinInfo");
-const getEthereumDefinitions = async ({
+import fetch from "cross-fetch";
+import { protobufManager } from "@trezor/protobuf";
+import { trzd } from "@trezor/protocol";
+import { Assert, Type } from "@trezor/schema-utils";
+import { ethereumNetworkInfoBase } from "../../data/coinInfo.js";
+import * as settingsStore from "../../data/settingsStore.js";
+const getDefinitionsBaseUrl = (channel = 'production') => {
+  switch (channel) {
+    case 'production':
+      return 'https://data.trezor.io/firmware/eth-definitions';
+    case 'development':
+      return 'https://data.trezor.io/dev/firmware/dev-definitions/eth';
+    case 'local':
+      return 'http://localhost:3000';
+    default:
+      throw new Error(`Unknown channel: ${channel}`);
+  }
+};
+export const getEthereumDefinitions = async ({
   chainId,
   slip44,
-  contractAddress
+  contractAddress,
+  functionSignature
 }) => {
   const definitions = {};
   if (!chainId && !slip44) {
     throw new Error('argument chainId or slip44 is required');
   }
+  const channel = settingsStore.isLoaded() ? settingsStore.get('definitionsChannel') : undefined;
+  const baseUrl = getDefinitionsBaseUrl(channel);
   try {
-    const networkDefinitionUrl = `https://data.trezor.io/firmware/eth-definitions/${chainId ? 'chain-id' : 'slip44'}/${chainId ?? slip44}/network.dat`;
-    const networkDefinition = await (0, cross_fetch_1.default)(networkDefinitionUrl);
+    const networkDefinitionUrl = `${baseUrl}/${chainId ? 'chain-id' : 'slip44'}/${chainId ?? slip44}/network.dat`;
+    const networkDefinition = await fetch(networkDefinitionUrl);
     if (networkDefinition.status === 200) {
       definitions.encoded_network = await networkDefinition.arrayBuffer();
     } else if (networkDefinition.status !== 404) {
-      throw new Error(`unexpected status: $${networkDefinition.status}`);
+      throw new Error(`unexpected status: ${networkDefinition.status}`);
     }
   } catch (err) {
     console.warn(`unable to download or parse ${chainId} definition. detail: ${err.message}`);
@@ -34,44 +42,57 @@ const getEthereumDefinitions = async ({
   try {
     if (contractAddress) {
       const lowerCaseContractAddress = contractAddress.toLowerCase();
-      const tokenDefinitionUrl = `https://data.trezor.io/firmware/eth-definitions/${chainId ? 'chain-id' : 'slip44'}/${chainId ?? slip44}/token-${lowerCaseContractAddress}.dat`;
-      const tokenDefinition = await (0, cross_fetch_1.default)(tokenDefinitionUrl);
+      const tokenDefinitionUrl = `${baseUrl}/${chainId ? 'chain-id' : 'slip44'}/${chainId ?? slip44}/token-${lowerCaseContractAddress}.dat`;
+      const tokenDefinition = await fetch(tokenDefinitionUrl);
       if (tokenDefinition.status === 200) {
         definitions.encoded_token = await tokenDefinition.arrayBuffer();
       } else if (tokenDefinition.status !== 404) {
-        throw new Error(`unexpected status: $${tokenDefinition.status}`);
+        throw new Error(`unexpected status: ${tokenDefinition.status}`);
       }
     }
   } catch (err) {
     console.warn(`unable to download or parse ${chainId}/${contractAddress} definition. detail: ${err.message}`);
   }
+  try {
+    if (chainId && contractAddress && functionSignature) {
+      const lowerCaseContractAddress = contractAddress.toLowerCase();
+      const lowerCaseFunctionSignature = functionSignature.toLowerCase();
+      const displayFormatUrl = `${baseUrl}/chain-id/${chainId}/display-format/${lowerCaseContractAddress}-${lowerCaseFunctionSignature}.dat`;
+      const displayFormatDefinition = await fetch(displayFormatUrl);
+      if (displayFormatDefinition.status === 200) {
+        const encodedDisplayFormat = await displayFormatDefinition.arrayBuffer();
+        definitions.encoded_display_format = Buffer.from(encodedDisplayFormat).toString('hex');
+      } else if (displayFormatDefinition.status !== 404) {
+        throw new Error(`unexpected status: ${displayFormatDefinition.status}`);
+      }
+    }
+  } catch (err) {
+    console.warn(`unable to download or parse ${chainId}/${contractAddress}/${functionSignature} display-format definition. detail: ${err.message}`);
+  }
   return definitions;
 };
-exports.getEthereumDefinitions = getEthereumDefinitions;
-exports.EthereumNetworkDefinitionDecoded = schema_utils_1.Type.Object({
-  chain_id: schema_utils_1.Type.Number(),
-  name: schema_utils_1.Type.String(),
-  slip44: schema_utils_1.Type.Number(),
-  symbol: schema_utils_1.Type.String()
+export const EthereumNetworkDefinitionDecoded = Type.Object({
+  chain_id: Type.Number(),
+  name: Type.String(),
+  slip44: Type.Number(),
+  symbol: Type.String()
 });
-exports.EthereumTokenDefinitionDecoded = schema_utils_1.Type.Object({
-  address: schema_utils_1.Type.String(),
-  chain_id: schema_utils_1.Type.Number(),
-  decimals: schema_utils_1.Type.Number(),
-  name: schema_utils_1.Type.String(),
-  symbol: schema_utils_1.Type.String()
+export const EthereumTokenDefinitionDecoded = Type.Object({
+  address: Type.String(),
+  chain_id: Type.Number(),
+  decimals: Type.Number(),
+  name: Type.String(),
+  symbol: Type.String()
 });
-exports.EthereumDefinitionDecoded = schema_utils_1.Type.Object({
-  network: schema_utils_1.Type.Optional(exports.EthereumNetworkDefinitionDecoded),
-  token: schema_utils_1.Type.Optional(exports.EthereumTokenDefinitionDecoded)
+export const EthereumDefinitionDecoded = Type.Object({
+  network: Type.Optional(EthereumNetworkDefinitionDecoded),
+  token: Type.Optional(EthereumTokenDefinitionDecoded)
 });
-const decodeEthereumDefinition = encodedDefinition => {
+export const decodeEthereumDefinition = encodedDefinition => {
   const decoded = {
     network: undefined,
     token: undefined
   };
-  const messages = DataManager_1.DataManager.getProtobufMessages();
-  const proto = (0, protobuf_1.parseConfigure)(messages);
   ['encoded_token', 'encoded_network'].forEach(key => {
     const encodedPayload = encodedDefinition[key];
     if (!encodedPayload) {
@@ -80,30 +101,28 @@ const decodeEthereumDefinition = encodedDefinition => {
     const {
       definitionType,
       protobufPayload
-    } = protocol_1.trzd.decode(encodedPayload);
+    } = trzd.decode(encodedPayload);
     const {
       message: decodedDefinition
-    } = (0, protobuf_1.decodeMessage)(proto, definitionType === 0 ? 'EthereumNetworkInfo' : 'EthereumTokenInfo', protobufPayload);
+    } = protobufManager.decode(definitionType === 0 ? 'EthereumNetworkInfo' : 'EthereumTokenInfo', protobufPayload);
     if (key === 'encoded_network') {
-      (0, schema_utils_1.Assert)(exports.EthereumNetworkDefinitionDecoded, decodedDefinition);
+      Assert(EthereumNetworkDefinitionDecoded, decodedDefinition);
       decoded.network = decodedDefinition;
     } else if (key === 'encoded_token') {
-      (0, schema_utils_1.Assert)(exports.EthereumTokenDefinitionDecoded, decodedDefinition);
+      Assert(EthereumTokenDefinitionDecoded, decodedDefinition);
       decoded.token = decodedDefinition;
     }
   });
   return decoded;
 };
-exports.decodeEthereumDefinition = decodeEthereumDefinition;
-const ethereumNetworkInfoFromDefinition = definition => ({
-  ...coinInfo_1.ethereumNetworkInfoBase,
+export const ethereumNetworkInfoFromDefinition = definition => ({
+  ...ethereumNetworkInfoBase,
   chainId: definition.chain_id,
   label: definition.name,
   name: definition.name,
   slip44: definition.slip44,
   shortcut: definition.symbol,
   support: {
-    connect: true,
     T1B1: '1.6.2',
     T2T1: '2.0.7',
     T2B1: '2.0.0',
@@ -113,6 +132,4 @@ const ethereumNetworkInfoFromDefinition = definition => ({
     UNKNOWN: '0.0.0'
   },
   blockchainLink: undefined
-});
-exports.ethereumNetworkInfoFromDefinition = ethereumNetworkInfoFromDefinition;
-//# sourceMappingURL=ethereumDefinitions.js.map
+});

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

@@ -1,22 +1,16 @@
-import { Common } from '@ethereumjs/common';
-import { MessagesSchema } from '@trezor/protobuf';
-import { PROTO } from '../../constants';
-import type { TypedCall } from '../../device/DeviceCommands';
-import type { EthereumAccessList, EthereumTransaction, EthereumTransactionEIP1559 } from '../../types/api/ethereum';
-export declare const getCommonForChain: (chainId: number) => Common;
+import type { EthereumAccessList, EthereumTransaction, EthereumTransactionEIP1559, PROTO } from '@trezor/connect-common';
+import type { MessagesSchema } from '@trezor/protobuf';
+import type { TypedCall } from "../../device/DeviceCommands.js";
+type TxSignature = {
+  v: `0x${string}`;
+  r: `0x${string}`;
+  s: `0x${string}`;
+};
 export declare const serializeEthereumTx: (tx: EthereumTransactionEIP1559 | EthereumTransaction, signature: {
-    v: `0x${string}`;
-    r: `0x${string}`;
-    s: `0x${string}`;
-}, isLegacy: boolean) => string;
-export declare const ethereumSignTx: (typedCall: TypedCall, address_n: number[], to: string | null, value: string, gas_limit: string, gas_price: string, nonce: string, chain_id: number, chunkify: boolean, data?: string, tx_type?: number, definitions?: MessagesSchema.EthereumDefinitions, payment_req?: PROTO.PaymentRequest) => Promise<{
-    v: `0x${string}`;
-    r: `0x${string}`;
-    s: `0x${string}`;
-}>;
-export declare const ethereumSignTxEIP1559: (typedCall: TypedCall, address_n: number[], to: string | null, value: string, gas_limit: string, max_gas_fee: string, max_priority_fee: string, nonce: string, chain_id: number, chunkify: boolean, data?: string, access_list?: EthereumAccessList[], definitions?: MessagesSchema.EthereumDefinitions, payment_req?: PROTO.PaymentRequest) => Promise<{
-    v: `0x${string}`;
-    r: `0x${string}`;
-    s: `0x${string}`;
-}>;
-//# sourceMappingURL=ethereumSignTx.d.ts.map
+  v: `0x${string}`;
+  r: `0x${string}`;
+  s: `0x${string}`;
+}, isLegacy: boolean) => `0x02${string}` | import("viem").TransactionSerializedLegacy;
+export declare const ethereumSignTx: (typedCall: TypedCall, address_n: number[], to: string | null, value: string, gas_limit: string, gas_price: string, nonce: string, chain_id: number, chunkify: boolean, data?: string, tx_type?: number, definitions?: MessagesSchema.EthereumDefinitions, payment_req?: PROTO.PaymentRequest) => Promise<TxSignature>;
+export declare const ethereumSignTxEIP1559: (typedCall: TypedCall, address_n: number[], to: string | null, value: string, gas_limit: string, max_gas_fee: string, max_priority_fee: string, nonce: string, chain_id: number, chunkify: boolean, data?: string, access_list?: EthereumAccessList[], definitions?: MessagesSchema.EthereumDefinitions, payment_req?: PROTO.PaymentRequest) => Promise<TxSignature>;
+export {};

package/lib/api/ethereum/ethereumSignTx.js

@@ -1,13 +1,7 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ethereumSignTxEIP1559 = exports.ethereumSignTx = exports.serializeEthereumTx = exports.getCommonForChain = void 0;
-const common_1 = require("@ethereumjs/common");
-const tx_1 = require("@ethereumjs/tx");
-const constants_1 = require("../../constants");
-const formatUtils_1 = require("../../utils/formatUtils");
+import { serializeTransaction } from "viem";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { getEthereumDefinitions } from "./ethereumDefinitions.js";
+import { addHexPrefix } from "../../utils/formatUtils.js";
 const splitString = (str, len) => {
   if (str == null) {
     return ['', ''];
@@ -16,13 +10,13 @@ const splitString = (str, len) => {
   const second = str.slice(len);
   return [first, second];
 };
-const processTxRequest = async (typedCall, request, data, chain_id) => {
+async function processTxRequest(typedCall, request, data, chain_id) {
   if (!request.data_length) {
     let v = request.signature_v;
     const r = request.signature_r;
     const s = request.signature_s;
     if (v == null || r == null || s == null) {
-      throw constants_1.ERRORS.TypedError('Runtime', 'processTxRequest: Unexpected request');
+      throw ERRORS.TypedError('Runtime', 'processTxRequest: Unexpected request');
     }
     if (chain_id && v <= 1) {
       v += 2 * chain_id + 35;
@@ -34,54 +28,63 @@ const processTxRequest = async (typedCall, request, data, chain_id) => {
     });
   }
   const [first, rest] = splitString(data, request.data_length * 2);
-  const response = await typedCall('EthereumTxAck', 'EthereumTxRequest', {
+  const nextResponse = await typedCall('EthereumTxAck', ['EthereumTxRequest', 'EthereumDefinitionRequest'], {
     data_chunk: first
   });
-  return processTxRequest(typedCall, response.message, rest, chain_id);
-};
-const deepHexPrefix = (0, formatUtils_1.deepTransform)(formatUtils_1.addHexPrefix);
-const getCommonForChain = chainId => {
-  if (chainId === 61) {
-    return (0, common_1.createCustomCommon)({
-      chainId: 61,
-      defaultHardfork: common_1.Hardfork.Petersburg
-    }, common_1.Mainnet);
-  }
-  return (0, common_1.createCustomCommon)({
-    chainId
-  }, common_1.Mainnet);
-};
-exports.getCommonForChain = getCommonForChain;
-const serializeEthereumTx = (tx, signature, isLegacy) => {
-  const txData = deepHexPrefix({
-    ...tx,
-    ...signature,
-    to: tx.to || undefined,
-    type: isLegacy ? 0 : 2,
-    ...(isLegacy ? {
-      gasPrice: tx.gasPrice,
-      maxFeePerGas: undefined,
-      maxPriorityFeePerGas: undefined
-    } : {
-      gasPrice: undefined,
-      maxFeePerGas: tx.maxFeePerGas,
-      maxPriorityFeePerGas: tx.maxPriorityFeePerGas
-    })
+  return handleTxFlowResponse(typedCall, nextResponse, rest, chain_id);
+}
+async function processDefinitionRequest(typedCall, request, data, chain_id) {
+  const definitions = await getEthereumDefinitions({
+    chainId: request.chain_id,
+    contractAddress: request.token_address,
+    functionSignature: request.func_sig
   });
-  const txOptions = {
-    common: (0, exports.getCommonForChain)(tx.chainId)
-  };
-  const ethTx = (0, tx_1.createTx)(txData, txOptions);
-  return `0x${Buffer.from(ethTx.serialize()).toString('hex')}`;
-};
-exports.serializeEthereumTx = serializeEthereumTx;
+  const nextResponse = await typedCall('EthereumDefinitionAck', ['EthereumTxRequest', 'EthereumDefinitionRequest'], {
+    definitions
+  });
+  return handleTxFlowResponse(typedCall, nextResponse, data, chain_id);
+}
+function handleTxFlowResponse(typedCall, response, data, chain_id) {
+  if (response.type === 'EthereumDefinitionRequest') {
+    return processDefinitionRequest(typedCall, response.message, data, chain_id);
+  }
+  return processTxRequest(typedCall, response.message, data, chain_id);
+}
+const ifNotUndefined = (value, convert) => value === undefined ? undefined : convert(value);
+const toBigInt = value => BigInt(addHexPrefix(value));
+export const serializeEthereumTx = (tx, signature, isLegacy) => serializeTransaction({
+  value: toBigInt(tx.value),
+  nonce: Number(addHexPrefix(tx.nonce)),
+  data: ifNotUndefined(tx.data, addHexPrefix),
+  to: ifNotUndefined(tx.to || undefined, addHexPrefix),
+  gas: ifNotUndefined(tx.gasLimit, toBigInt),
+  chainId: tx.chainId,
+  ...(isLegacy ? {
+    type: 'legacy',
+    gasPrice: ifNotUndefined(tx.gasPrice, toBigInt)
+  } : {
+    type: 'eip1559',
+    maxFeePerGas: ifNotUndefined(tx.maxFeePerGas, toBigInt),
+    maxPriorityFeePerGas: ifNotUndefined(tx.maxPriorityFeePerGas, toBigInt),
+    accessList: ('accessList' in tx ? tx.accessList : undefined)?.map(({
+      address,
+      storageKeys
+    }) => ({
+      address: addHexPrefix(address),
+      storageKeys: storageKeys.map(addHexPrefix)
+    }))
+  })
+}, {
+  ...signature,
+  v: toBigInt(signature.v)
+});
 const stripLeadingZeroes = str => {
   while (/^00/.test(str)) {
     str = str.slice(2);
   }
   return str;
 };
-const ethereumSignTx = async (typedCall, address_n, to, value, gas_limit, gas_price, nonce, chain_id, chunkify, data, tx_type, definitions, payment_req) => {
+export const ethereumSignTx = async (typedCall, address_n, to, value, gas_limit, gas_price, nonce, chain_id, chunkify, data, tx_type, definitions, payment_req) => {
   const length = data == null ? 0 : data.length / 2;
   const [first, rest] = splitString(data, 1024 * 2);
   let message = {
@@ -94,7 +97,8 @@ const ethereumSignTx = async (typedCall, address_n, to, value, gas_limit, gas_pr
     value: stripLeadingZeroes(value),
     definitions,
     chunkify,
-    payment_req
+    payment_req,
+    supports_definition_request: true
   };
   if (length !== 0) {
     message = {
@@ -109,11 +113,10 @@ const ethereumSignTx = async (typedCall, address_n, to, value, gas_limit, gas_pr
       tx_type
     };
   }
-  const response = await typedCall('EthereumSignTx', 'EthereumTxRequest', message);
-  return processTxRequest(typedCall, response.message, rest, chain_id);
+  const response = await typedCall('EthereumSignTx', ['EthereumTxRequest', 'EthereumDefinitionRequest'], message);
+  return handleTxFlowResponse(typedCall, response, rest, chain_id);
 };
-exports.ethereumSignTx = ethereumSignTx;
-const ethereumSignTxEIP1559 = async (typedCall, address_n, to, value, gas_limit, max_gas_fee, max_priority_fee, nonce, chain_id, chunkify, data, access_list, definitions, payment_req) => {
+export const ethereumSignTxEIP1559 = async (typedCall, address_n, to, value, gas_limit, max_gas_fee, max_priority_fee, nonce, chain_id, chunkify, data, access_list, definitions, payment_req) => {
   const length = data == null ? 0 : data.length / 2;
   const [first, rest] = splitString(data, 1024 * 2);
   const message = {
@@ -133,10 +136,9 @@ const ethereumSignTxEIP1559 = async (typedCall, address_n, to, value, gas_limit,
     })),
     definitions,
     chunkify,
-    payment_req
+    payment_req,
+    supports_definition_request: true
   };
-  const response = await typedCall('EthereumSignTxEIP1559', 'EthereumTxRequest', message);
-  return processTxRequest(typedCall, response.message, rest);
-};
-exports.ethereumSignTxEIP1559 = ethereumSignTxEIP1559;
-//# sourceMappingURL=ethereumSignTx.js.map
+  const response = await typedCall('EthereumSignTxEIP1559', ['EthereumTxRequest', 'EthereumDefinitionRequest'], message);
+  return handleTxFlowResponse(typedCall, response, rest);
+};

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

@@ -1,9 +1,32 @@
-import { PROTO } from '../../constants';
-import type { EthereumSignTypedDataTypes } from '../../types/api/ethereum';
+import type { EthereumSignTypedDataTypes } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
 export declare function parseArrayType(arrayTypeName: string): {
-    entryTypeName: string;
-    arraySize: number | null;
+  entryTypeName: string;
+  arraySize: number | null;
 };
 export declare function encodeData(typeName: string, data: any): string;
 export declare function getFieldType(typeName: string, types: EthereumSignTypedDataTypes): PROTO.EthereumFieldType;
-//# sourceMappingURL=ethereumSignTypedData.d.ts.map
+type LooseTypedDataDomain = {
+  name?: string;
+  version?: string;
+  chainId?: string | number | bigint;
+  verifyingContract?: string;
+  salt?: string | ArrayBuffer;
+};
+type TransformTypedDataInput<T extends Record<string, readonly {
+  name: string;
+  type: string;
+}[]>> = {
+  types: T;
+  primaryType: keyof T | string;
+  domain: LooseTypedDataDomain;
+  message: Record<string, unknown>;
+};
+export declare const transformTypedData: <T extends Record<string, readonly {
+  name: string;
+  type: string;
+}[]>>(data: TransformTypedDataInput<T>, metamask_v4_compat: boolean) => {
+  domain_separator_hash: string;
+  message_hash: string | null;
+};
+export {};

package/lib/api/ethereum/ethereumSignTypedData.js

@@ -1,23 +1,19 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.parseArrayType = parseArrayType;
-exports.encodeData = encodeData;
-exports.getFieldType = getFieldType;
-const bigNumber_1 = require("@trezor/utils/lib/bigNumber");
-const constants_1 = require("../../constants");
-const formatUtils_1 = require("../../utils/formatUtils");
+import { hashDomain, hashStruct } from "viem";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { getIndexOrThrow } from "@trezor/utils";
+import { BigNumber } from "@trezor/utils/lib/bigNumber.js";
+import { messageToHex } from "../../utils/formatUtils.js";
 const paramTypeArray = new RegExp(/^(.*)\[([0-9]*)\]$/);
 const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);
 const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
-function parseArrayType(arrayTypeName) {
+export function parseArrayType(arrayTypeName) {
   const arrayMatch = paramTypeArray.exec(arrayTypeName);
   if (arrayMatch === null) {
-    throw constants_1.ERRORS.TypedError('Runtime', `typename ${arrayTypeName} could not be parsed as an EIP-712 array`);
+    throw ERRORS.TypedError('Runtime', `typename ${arrayTypeName} could not be parsed as an EIP-712 array`);
   }
-  const [_, entryTypeName, arraySize] = arrayMatch;
+  const entryTypeName = arrayMatch[1] ?? '';
+  const arraySize = arrayMatch[2] ?? '';
   return {
     entryTypeName,
     arraySize: parseInt(arraySize, 10) || null
@@ -25,13 +21,13 @@ function parseArrayType(arrayTypeName) {
 }
 function twosComplement(number, bytes) {
   if (bytes < 1 || bytes > 32) {
-    throw constants_1.ERRORS.TypedError('Runtime', 'Int byte size must be between 1 and 32 (8 and 256 bits)');
+    throw ERRORS.TypedError('Runtime', 'Int byte size must be between 1 and 32 (8 and 256 bits)');
   }
-  const minValue = new bigNumber_1.BigNumber(2).exponentiatedBy(bytes * 8 - 1).negated();
+  const minValue = new BigNumber(2).exponentiatedBy(bytes * 8 - 1).negated();
   const maxValue = minValue.negated().minus(1);
-  const bigNumber = new bigNumber_1.BigNumber(number);
+  const bigNumber = new BigNumber(number);
   if (bigNumber.isGreaterThan(maxValue) || bigNumber.isLessThan(minValue)) {
-    throw constants_1.ERRORS.TypedError('Runtime', `Overflow when trying to convert number ${number} into ${bytes} bytes`);
+    throw ERRORS.TypedError('Runtime', `Overflow when trying to convert number ${number} into ${bytes} bytes`);
   }
   if (bigNumber.isPositive()) {
     return bigNumber;
@@ -39,67 +35,70 @@ function twosComplement(number, bytes) {
   return bigNumber.minus(minValue).minus(minValue);
 }
 function intToHex(number, bytes, signed) {
-  let bigNumber = new bigNumber_1.BigNumber(number);
+  let bigNumber = new BigNumber(number);
   if (signed) {
     bigNumber = twosComplement(bigNumber, bytes);
   }
   if (bigNumber.isNegative()) {
-    throw constants_1.ERRORS.TypedError('Runtime', `Cannot convert negative number to unsigned interger: ${number}`);
+    throw ERRORS.TypedError('Runtime', `Cannot convert negative number to unsigned interger: ${number}`);
   }
   const hex = bigNumber.toString(16);
   const hexChars = bytes * 2;
   if (hex.length > hexChars) {
-    throw constants_1.ERRORS.TypedError('Runtime', `Overflow when trying to convert number ${number} into ${bytes} bytes`);
+    throw ERRORS.TypedError('Runtime', `Overflow when trying to convert number ${number} into ${bytes} bytes`);
   }
   return hex.padStart(bytes * 2, '0');
 }
-function encodeData(typeName, data) {
+export function encodeData(typeName, data) {
   if (paramTypeBytes.test(typeName) || typeName === 'address') {
-    return (0, formatUtils_1.messageToHex)(data);
+    return messageToHex(data);
   }
   if (typeName === 'string') {
     return Buffer.from(data, 'utf-8').toString('hex');
   }
   const numberMatch = paramTypeNumber.exec(typeName);
   if (numberMatch) {
-    const [_, intType, bits] = numberMatch;
-    const bytes = Math.ceil(parseInt(bits, 10) / 8);
+    const intType = numberMatch[1] ?? '';
+    const bits = numberMatch[2] ?? '';
+    const bytes = Math.ceil((bits === '' ? 256 : parseInt(bits, 10)) / 8);
     return intToHex(data, bytes, intType === 'int');
   }
   if (typeName === 'bool') {
     return data ? '01' : '00';
   }
-  throw constants_1.ERRORS.TypedError('Runtime', `Unsupported data type for direct field encoding: ${typeName}`);
+  throw ERRORS.TypedError('Runtime', `Unsupported data type for direct field encoding: ${typeName}`);
 }
 const paramTypesMap = {
-  string: constants_1.PROTO.EthereumDataType.STRING,
-  bool: constants_1.PROTO.EthereumDataType.BOOL,
-  address: constants_1.PROTO.EthereumDataType.ADDRESS
+  string: PROTO.EthereumDataType.STRING,
+  bool: PROTO.EthereumDataType.BOOL,
+  address: PROTO.EthereumDataType.ADDRESS
 };
-function getFieldType(typeName, types) {
+export function getFieldType(typeName, types) {
   const arrayMatch = paramTypeArray.exec(typeName);
   if (arrayMatch) {
-    const [_, arrayItemTypeName, arraySize] = arrayMatch;
+    const arrayItemTypeName = arrayMatch[1] ?? '';
+    const arraySize = arrayMatch[2] ?? '';
     const entryType = getFieldType(arrayItemTypeName, types);
     return {
-      data_type: constants_1.PROTO.EthereumDataType.ARRAY,
+      data_type: PROTO.EthereumDataType.ARRAY,
       size: parseInt(arraySize, 10) || undefined,
       entry_type: entryType
     };
   }
   const numberMatch = paramTypeNumber.exec(typeName);
   if (numberMatch) {
-    const [_, type, bits] = numberMatch;
+    const type = numberMatch[1] ?? '';
+    const bits = numberMatch[2] ?? '';
     return {
-      data_type: type === 'uint' ? constants_1.PROTO.EthereumDataType.UINT : constants_1.PROTO.EthereumDataType.INT,
-      size: Math.floor(parseInt(bits, 10) / 8)
+      data_type: type === 'uint' ? PROTO.EthereumDataType.UINT : PROTO.EthereumDataType.INT,
+      size: Math.floor((bits === '' ? 256 : parseInt(bits, 10)) / 8)
     };
   }
   const bytesMatch = paramTypeBytes.exec(typeName);
   if (bytesMatch) {
-    const [_, size] = bytesMatch;
+    const size = bytesMatch[1] ?? '';
     return {
-      data_type: constants_1.PROTO.EthereumDataType.BYTES,
+      data_type: PROTO.EthereumDataType.BYTES,
       size: parseInt(size, 10) || undefined
     };
   }
@@ -110,12 +109,67 @@ function getFieldType(typeName, types) {
     };
   }
   if (typeName in types) {
+    const typeDef = types[typeName];
     return {
-      data_type: constants_1.PROTO.EthereumDataType.STRUCT,
-      size: types[typeName].length,
+      data_type: PROTO.EthereumDataType.STRUCT,
+      size: typeDef.length,
       struct_name: typeName
     };
   }
-  throw constants_1.ERRORS.TypedError('Runtime', `No type definition specified: ${typeName}`);
+  throw ERRORS.TypedError('Runtime', `No type definition specified: ${typeName}`);
 }
-//# sourceMappingURL=ethereumSignTypedData.js.map
+const arrayBufferToHex = buf => {
+  const bytes = new Uint8Array(buf);
+  let hex = '0x';
+  for (let i = 0; i < bytes.length; i += 1) {
+    hex += getIndexOrThrow(bytes, i).toString(16).padStart(2, '0');
+  }
+  return hex;
+};
+const ensureHexPrefix = value => {
+  if (value === undefined) return undefined;
+  return value.startsWith('0x') ? value : `0x${value}`;
+};
+const normalizeDomain = domain => {
+  let {
+    chainId
+  } = domain;
+  if (typeof chainId === 'string') {
+    try {
+      chainId = BigInt(chainId);
+    } catch {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Trezor: Invalid typed data domain chainId. Expected an integer-compatible string.');
+    }
+  }
+  const saltAsString = domain.salt instanceof ArrayBuffer ? arrayBufferToHex(domain.salt) : domain.salt;
+  return {
+    ...domain,
+    chainId,
+    verifyingContract: ensureHexPrefix(domain.verifyingContract),
+    salt: ensureHexPrefix(saltAsString)
+  };
+};
+export const transformTypedData = (data, metamask_v4_compat) => {
+  if (!metamask_v4_compat) {
+    throw ERRORS.TypedError('Method_InvalidParameter', 'Trezor: Only version 4 of typed data signing is supported');
+  }
+  if (!data.types || !('EIP712Domain' in data.types)) {
+    throw ERRORS.TypedError('Method_InvalidParameter', 'Trezor: EIP712Domain type definition required in types');
+  }
+  const domain_separator_hash = hashDomain({
+    domain: normalizeDomain(data.domain),
+    types: data.types
+  }).slice(2);
+  let message_hash = null;
+  if (data.primaryType !== 'EIP712Domain') {
+    message_hash = hashStruct({
+      data: data.message,
+      primaryType: data.primaryType,
+      types: data.types
+    }).slice(2);
+  }
+  return {
+    domain_separator_hash,
+    message_hash
+  };
+};