@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/api/ethereum/api/index.mjs

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

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

@@ -0,0 +1,46 @@
+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;
+}
+export declare const getEthereumDefinitions: ({ chainId, slip44, contractAddress, }: GetEthereumDefinitions) => Promise<{
+    encoded_network?: ArrayBuffer | undefined;
+    encoded_token?: ArrayBuffer | 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/libESM/api/ethereum/ethereumDefinitions.mjs

@@ -0,0 +1,103 @@
+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.mjs";
+export const getEthereumDefinitions = async ({
+  chainId,
+  slip44,
+  contractAddress
+}) => {
+  const definitions = {};
+  if (!chainId && !slip44) {
+    throw new Error('argument chainId or slip44 is required');
+  }
+  try {
+    const networkDefinitionUrl = `https://data.trezor.io/firmware/eth-definitions/${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 = `https://data.trezor.io/firmware/eth-definitions/${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}`);
+  }
+  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/libESM/api/ethereum/ethereumSignTx.d.mts

@@ -0,0 +1,20 @@
+import type { Common } from '@ethereumjs/common';
+import type { EthereumAccessList, EthereumTransaction, EthereumTransactionEIP1559, PROTO } from '@trezor/connect-common';
+import type { MessagesSchema } from '@trezor/protobuf';
+import type { TypedCall } from '../../device/DeviceCommands';
+export declare const getCommonForChain: (chainId: number) => Common;
+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}`;
+}>;

package/libESM/api/ethereum/ethereumSignTx.mjs

@@ -0,0 +1,131 @@
+import { Hardfork, Mainnet, createCustomCommon } from "@ethereumjs/common";
+import { createTx } from "@ethereumjs/tx";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { addHexPrefix, deepTransform } from "../../utils/formatUtils.mjs";
+const splitString = (str, len) => {
+  if (str == null) {
+    return ['', ''];
+  }
+  const first = str.slice(0, len);
+  const second = str.slice(len);
+  return [first, second];
+};
+const processTxRequest = async (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 response = await typedCall('EthereumTxAck', 'EthereumTxRequest', {
+    data_chunk: first
+  });
+  return processTxRequest(typedCall, response.message, rest, chain_id);
+};
+const deepHexPrefix = deepTransform(addHexPrefix);
+export const getCommonForChain = chainId => {
+  if (chainId === 61) {
+    return createCustomCommon({
+      chainId: 61,
+      defaultHardfork: Hardfork.Petersburg
+    }, Mainnet);
+  }
+  return createCustomCommon({
+    chainId
+  }, Mainnet);
+};
+export 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
+    })
+  });
+  const txOptions = {
+    common: getCommonForChain(tx.chainId)
+  };
+  const ethTx = createTx(txData, txOptions);
+  return `0x${Buffer.from(ethTx.serialize()).toString('hex')}`;
+};
+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
+  };
+  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', message);
+  return processTxRequest(typedCall, response.message, 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
+  };
+  const response = await typedCall('EthereumSignTxEIP1559', 'EthereumTxRequest', message);
+  return processTxRequest(typedCall, response.message, rest);
+};

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

@@ -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/libESM/api/ethereum/ethereumSignTypedData.mjs

@@ -0,0 +1,169 @@
+import { hashDomain, hashStruct } from "viem";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { BigNumber } from "@trezor/utils/libESM/bigNumber.mjs";
+import { messageToHex } from "../../utils/formatUtils.mjs";
+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, arraySize] = arrayMatch;
+  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, bits] = numberMatch;
+    const bytes = Math.ceil(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, arraySize] = arrayMatch;
+    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, bits] = numberMatch;
+    return {
+      data_type: type === 'uint' ? PROTO.EthereumDataType.UINT : PROTO.EthereumDataType.INT,
+      size: Math.floor(parseInt(bits, 10) / 8)
+    };
+  }
+  const bytesMatch = paramTypeBytes.exec(typeName);
+  if (bytesMatch) {
+    const [_, size] = bytesMatch;
+    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) {
+    return {
+      data_type: PROTO.EthereumDataType.STRUCT,
+      size: types[typeName].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 += 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/libESM/api/evoluGetDelegatedIdentityKey.d.mts

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

package/libESM/api/evoluGetDelegatedIdentityKey.mjs

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

package/libESM/api/evoluGetNode.d.mts

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

package/libESM/api/evoluGetNode.mjs

@@ -0,0 +1,27 @@
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+export default class EvoluGetNode extends AbstractMethod {
+  hasBundle;
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(PROTO.EvoluGetNode, payload);
+    const params = {
+      proof_of_delegated_identity: payload.proof_of_delegated_identity
+    };
+    super(message, params);
+  }
+  get requiredPermissions() {
+    return ['read'];
+  }
+  get info() {
+    return 'Evolu get node';
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('EvoluGetNode', 'EvoluNode', this.params);
+    return response.message;
+  }
+}

package/libESM/api/evoluSignRegistrationRequest.d.mts

@@ -0,0 +1,15 @@
+import { type MethodPermission } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+export default class EvoluSignRegistrationRequest extends AbstractMethod<'evoluSignRegistrationRequest', PROTO.EvoluSignRegistrationRequest> {
+    hasBundle?: boolean;
+    constructor(message: MethodMessage<'evoluSignRegistrationRequest'>);
+    get requiredPermissions(): MethodPermission[];
+    init(): void;
+    get info(): string;
+    run(): Promise<{
+        signature: string;
+        certificate_chain: string[];
+    }>;
+}

package/libESM/api/evoluSignRegistrationRequest.mjs

@@ -0,0 +1,31 @@
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+export default class EvoluSignRegistrationRequest extends AbstractMethod {
+  hasBundle;
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(PROTO.EvoluSignRegistrationRequest, payload);
+    const params = {
+      challenge_from_server: payload.challenge_from_server,
+      size_to_acquire: payload.size_to_acquire,
+      proof_of_delegated_identity: payload.proof_of_delegated_identity
+    };
+    super(message, params);
+    this.useEmptyPassphrase = true;
+  }
+  get requiredPermissions() {
+    return ['read'];
+  }
+  init() {}
+  get info() {
+    return 'Evolu sign registration request';
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('EvoluSignRegistrationRequest', 'EvoluRegistrationRequest', this.params);
+    return response.message;
+  }
+}

package/libESM/api/firmware/calculateFirmwareHash.d.mts

@@ -0,0 +1,13 @@
+import { DeviceModelInternal } from '@trezor/device-utils';
+import type { VersionArray } from '@trezor/utils/libESM/versionUtils';
+type CalculateFirmwareHashParams = {
+    internal_model: DeviceModelInternal;
+    fw: Buffer;
+    firmwareVersion: VersionArray;
+    key?: Buffer;
+};
+export declare const calculateFirmwareHash: ({ internal_model, firmwareVersion, fw, key, }: CalculateFirmwareHashParams) => {
+    hash: string;
+    challenge: string;
+};
+export {};