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

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

@@ -1,35 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,135 +0,0 @@
-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

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

@@ -1,144 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,175 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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;
-  }>;
-}