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

package/lib/api/ethereum/api/ethereumVerifyMessage.js

@@ -0,0 +1,35 @@
+import { EthereumVerifyMessage as EthereumVerifyMessageSchema } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { validateModelOneMessageSize } from "../../../device/validateMessageSize.js";
+import { messageToHex, stripHexPrefix } from "../../../utils/formatUtils.js";
+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 [{
+      permission: 'verify_message'
+    }];
+  }
+  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/lib/api/ethereum/api/index.d.ts

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

package/lib/api/ethereum/api/index.js

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

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

@@ -0,0 +1,53 @@
+import type { EthereumNetworkInfoDefinitionValues } from '@trezor/connect-common';
+import type { MessagesSchema } from '@trezor/protobuf';
+import type { Static } from '@trezor/schema-utils';
+interface GetEthereumDefinitions {
+  chainId?: number;
+  slip44?: number;
+  contractAddress?: string;
+  functionSignature?: string;
+}
+export declare const getEthereumDefinitions: ({
+  chainId,
+  slip44,
+  contractAddress,
+  functionSignature
+}: GetEthereumDefinitions) => Promise<{
+  encoded_network?: ArrayBuffer | undefined;
+  encoded_token?: ArrayBuffer | undefined;
+  encoded_display_format?: string | undefined;
+}>;
+export type EthereumNetworkDefinitionDecoded = Static<typeof EthereumNetworkDefinitionDecoded>;
+export declare const EthereumNetworkDefinitionDecoded: import("@sinclair/typebox").TObject<{
+  chain_id: import("@sinclair/typebox").TNumber;
+  name: import("@sinclair/typebox").TString;
+  slip44: import("@sinclair/typebox").TNumber;
+  symbol: import("@sinclair/typebox").TString;
+}>;
+export type EthereumTokenDefinitionDecoded = Static<typeof EthereumTokenDefinitionDecoded>;
+export declare const EthereumTokenDefinitionDecoded: import("@sinclair/typebox").TObject<{
+  address: import("@sinclair/typebox").TString;
+  chain_id: import("@sinclair/typebox").TNumber;
+  decimals: import("@sinclair/typebox").TNumber;
+  name: import("@sinclair/typebox").TString;
+  symbol: import("@sinclair/typebox").TString;
+}>;
+export type EthereumDefinitionDecoded = Static<typeof EthereumDefinitionDecoded>;
+export declare const EthereumDefinitionDecoded: import("@sinclair/typebox").TObject<{
+  network: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+    chain_id: import("@sinclair/typebox").TNumber;
+    name: import("@sinclair/typebox").TString;
+    slip44: import("@sinclair/typebox").TNumber;
+    symbol: import("@sinclair/typebox").TString;
+  }>>;
+  token: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+    chain_id: import("@sinclair/typebox").TNumber;
+    decimals: import("@sinclair/typebox").TNumber;
+    name: import("@sinclair/typebox").TString;
+    symbol: import("@sinclair/typebox").TString;
+  }>>;
+}>;
+export declare const decodeEthereumDefinition: (encodedDefinition: MessagesSchema.EthereumDefinitions) => EthereumDefinitionDecoded;
+export declare const ethereumNetworkInfoFromDefinition: (definition: EthereumNetworkDefinitionDecoded) => EthereumNetworkInfoDefinitionValues;
+export {};

package/lib/api/ethereum/ethereumDefinitions.js

@@ -0,0 +1,135 @@
+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,
+  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 = `${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}`);
+    }
+  } catch (err) {
+    console.warn(`unable to download or parse ${chainId} definition. detail: ${err.message}`);
+  }
+  try {
+    if (contractAddress) {
+      const lowerCaseContractAddress = contractAddress.toLowerCase();
+      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}`);
+      }
+    }
+  } 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;
+};
+export const EthereumNetworkDefinitionDecoded = Type.Object({
+  chain_id: Type.Number(),
+  name: Type.String(),
+  slip44: Type.Number(),
+  symbol: Type.String()
+});
+export const EthereumTokenDefinitionDecoded = Type.Object({
+  address: Type.String(),
+  chain_id: Type.Number(),
+  decimals: Type.Number(),
+  name: Type.String(),
+  symbol: Type.String()
+});
+export const EthereumDefinitionDecoded = Type.Object({
+  network: Type.Optional(EthereumNetworkDefinitionDecoded),
+  token: Type.Optional(EthereumTokenDefinitionDecoded)
+});
+export const decodeEthereumDefinition = encodedDefinition => {
+  const decoded = {
+    network: undefined,
+    token: undefined
+  };
+  ['encoded_token', 'encoded_network'].forEach(key => {
+    const encodedPayload = encodedDefinition[key];
+    if (!encodedPayload) {
+      return;
+    }
+    const {
+      definitionType,
+      protobufPayload
+    } = trzd.decode(encodedPayload);
+    const {
+      message: decodedDefinition
+    } = protobufManager.decode(definitionType === 0 ? 'EthereumNetworkInfo' : 'EthereumTokenInfo', protobufPayload);
+    if (key === 'encoded_network') {
+      Assert(EthereumNetworkDefinitionDecoded, decodedDefinition);
+      decoded.network = decodedDefinition;
+    } else if (key === 'encoded_token') {
+      Assert(EthereumTokenDefinitionDecoded, decodedDefinition);
+      decoded.token = decodedDefinition;
+    }
+  });
+  return decoded;
+};
+export const ethereumNetworkInfoFromDefinition = definition => ({
+  ...ethereumNetworkInfoBase,
+  chainId: definition.chain_id,
+  label: definition.name,
+  name: definition.name,
+  slip44: definition.slip44,
+  shortcut: definition.symbol,
+  support: {
+    T1B1: '1.6.2',
+    T2T1: '2.0.7',
+    T2B1: '2.0.0',
+    T3B1: '2.0.0',
+    T3T1: '2.0.0',
+    T3W1: '2.0.0',
+    UNKNOWN: '0.0.0'
+  },
+  blockchainLink: undefined
+});

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

@@ -0,0 +1,16 @@
+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) => `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

@@ -0,0 +1,144 @@
+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 ['', ''];
+  }
+  const first = str.slice(0, len);
+  const second = str.slice(len);
+  return [first, second];
+};
+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 ERRORS.TypedError('Runtime', 'processTxRequest: Unexpected request');
+    }
+    if (chain_id && v <= 1) {
+      v += 2 * chain_id + 35;
+    }
+    return Promise.resolve({
+      v: `0x${v.toString(16)}`,
+      r: `0x${r}`,
+      s: `0x${s}`
+    });
+  }
+  const [first, rest] = splitString(data, request.data_length * 2);
+  const nextResponse = await typedCall('EthereumTxAck', ['EthereumTxRequest', 'EthereumDefinitionRequest'], {
+    data_chunk: first
+  });
+  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 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;
+};
+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 = {
+    address_n,
+    chain_id,
+    nonce: stripLeadingZeroes(nonce),
+    gas_price: stripLeadingZeroes(gas_price),
+    gas_limit: stripLeadingZeroes(gas_limit),
+    to: to || undefined,
+    value: stripLeadingZeroes(value),
+    definitions,
+    chunkify,
+    payment_req,
+    supports_definition_request: true
+  };
+  if (length !== 0) {
+    message = {
+      ...message,
+      data_length: length,
+      data_initial_chunk: first
+    };
+  }
+  if (tx_type !== null) {
+    message = {
+      ...message,
+      tx_type
+    };
+  }
+  const response = await typedCall('EthereumSignTx', ['EthereumTxRequest', 'EthereumDefinitionRequest'], message);
+  return handleTxFlowResponse(typedCall, response, rest, chain_id);
+};
+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 = {
+    address_n,
+    nonce: stripLeadingZeroes(nonce),
+    max_gas_fee: stripLeadingZeroes(max_gas_fee),
+    max_priority_fee: stripLeadingZeroes(max_priority_fee),
+    gas_limit: stripLeadingZeroes(gas_limit),
+    to: to || undefined,
+    value: stripLeadingZeroes(value),
+    data_length: length,
+    data_initial_chunk: first,
+    chain_id,
+    access_list: (access_list || []).map(a => ({
+      address: a.address,
+      storage_keys: a.storageKeys
+    })),
+    definitions,
+    chunkify,
+    payment_req,
+    supports_definition_request: true
+  };
+  const response = await typedCall('EthereumSignTxEIP1559', ['EthereumTxRequest', 'EthereumDefinitionRequest'], message);
+  return handleTxFlowResponse(typedCall, response, rest);
+};

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

@@ -0,0 +1,32 @@
+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;
+};
+export declare function encodeData(typeName: string, data: any): string;
+export declare function getFieldType(typeName: string, types: EthereumSignTypedDataTypes): PROTO.EthereumFieldType;
+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

@@ -0,0 +1,175 @@
+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]*)$/);
+export function parseArrayType(arrayTypeName) {
+  const arrayMatch = paramTypeArray.exec(arrayTypeName);
+  if (arrayMatch === null) {
+    throw ERRORS.TypedError('Runtime', `typename ${arrayTypeName} could not be parsed as an EIP-712 array`);
+  }
+  const entryTypeName = arrayMatch[1] ?? '';
+  const arraySize = arrayMatch[2] ?? '';
+  return {
+    entryTypeName,
+    arraySize: parseInt(arraySize, 10) || null
+  };
+}
+function twosComplement(number, bytes) {
+  if (bytes < 1 || bytes > 32) {
+    throw ERRORS.TypedError('Runtime', 'Int byte size must be between 1 and 32 (8 and 256 bits)');
+  }
+  const minValue = new BigNumber(2).exponentiatedBy(bytes * 8 - 1).negated();
+  const maxValue = minValue.negated().minus(1);
+  const bigNumber = new BigNumber(number);
+  if (bigNumber.isGreaterThan(maxValue) || bigNumber.isLessThan(minValue)) {
+    throw ERRORS.TypedError('Runtime', `Overflow when trying to convert number ${number} into ${bytes} bytes`);
+  }
+  if (bigNumber.isPositive()) {
+    return bigNumber;
+  }
+  return bigNumber.minus(minValue).minus(minValue);
+}
+function intToHex(number, bytes, signed) {
+  let bigNumber = new BigNumber(number);
+  if (signed) {
+    bigNumber = twosComplement(bigNumber, bytes);
+  }
+  if (bigNumber.isNegative()) {
+    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 ERRORS.TypedError('Runtime', `Overflow when trying to convert number ${number} into ${bytes} bytes`);
+  }
+  return hex.padStart(bytes * 2, '0');
+}
+export function encodeData(typeName, data) {
+  if (paramTypeBytes.test(typeName) || typeName === 'address') {
+    return messageToHex(data);
+  }
+  if (typeName === 'string') {
+    return Buffer.from(data, 'utf-8').toString('hex');
+  }
+  const numberMatch = paramTypeNumber.exec(typeName);
+  if (numberMatch) {
+    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 ERRORS.TypedError('Runtime', `Unsupported data type for direct field encoding: ${typeName}`);
+}
+const paramTypesMap = {
+  string: PROTO.EthereumDataType.STRING,
+  bool: PROTO.EthereumDataType.BOOL,
+  address: PROTO.EthereumDataType.ADDRESS
+};
+export function getFieldType(typeName, types) {
+  const arrayMatch = paramTypeArray.exec(typeName);
+  if (arrayMatch) {
+    const arrayItemTypeName = arrayMatch[1] ?? '';
+    const arraySize = arrayMatch[2] ?? '';
+    const entryType = getFieldType(arrayItemTypeName, types);
+    return {
+      data_type: PROTO.EthereumDataType.ARRAY,
+      size: parseInt(arraySize, 10) || undefined,
+      entry_type: entryType
+    };
+  }
+  const numberMatch = paramTypeNumber.exec(typeName);
+  if (numberMatch) {
+    const type = numberMatch[1] ?? '';
+    const bits = numberMatch[2] ?? '';
+    return {
+      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[1] ?? '';
+    return {
+      data_type: PROTO.EthereumDataType.BYTES,
+      size: parseInt(size, 10) || undefined
+    };
+  }
+  const fixedSizeTypeMatch = paramTypesMap[typeName];
+  if (fixedSizeTypeMatch) {
+    return {
+      data_type: fixedSizeTypeMatch
+    };
+  }
+  if (typeName in types) {
+    const typeDef = types[typeName];
+    return {
+      data_type: PROTO.EthereumDataType.STRUCT,
+      size: typeDef.length,
+      struct_name: typeName
+    };
+  }
+  throw ERRORS.TypedError('Runtime', `No type definition specified: ${typeName}`);
+}
+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
+  };
+};

package/lib/api/evoluGetDelegatedIdentityKey.d.ts

@@ -0,0 +1,14 @@
+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 EvoluGetDelegatedIdentityKey extends AbstractMethod<'evoluGetDelegatedIdentityKey', PROTO.EvoluGetDelegatedIdentityKey> {
+  hasBundle?: boolean;
+  constructor(message: MethodMessage<'evoluGetDelegatedIdentityKey'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<{
+    rotation_index?: number | undefined;
+    private_key: string;
+  }>;
+}

package/lib/api/evoluGetDelegatedIdentityKey.js

@@ -0,0 +1,29 @@
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class EvoluGetDelegatedIdentityKey extends AbstractMethod {
+  hasBundle;
+  constructor(message) {
+    super(message, {});
+    this.useDevice = true;
+    this.useUi = true;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'read_xpub'
+    }];
+  }
+  get info() {
+    return 'Evolu get delegated identity key';
+  }
+  async run() {
+    const thpState = this.getDevice().getThpState();
+    if (thpState) {
+      const firstCredential = thpState.pairingCredentials[0];
+      this.params = {
+        thp_credential: firstCredential.credential
+      };
+    }
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('EvoluGetDelegatedIdentityKey', 'EvoluDelegatedIdentityKey', this.params);
+    return response.message;
+  }
+}

package/lib/api/evoluGetNode.d.ts

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