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

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

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

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

@@ -1,103 +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.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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,10 +0,0 @@
-import type { XPubHashesPerBip43Path } from '@trezor/connect-common';
-export declare const calculateXPubHash: (xpub: string) => string;
-export declare const calculateXPubHashes: (xpubs: Record<string, string>) => XPubHashesPerBip43Path;
-type CheckXPubWithHashesParams = {
-    xpub: string;
-    path: string;
-    knownXPubHashes: XPubHashesPerBip43Path;
-};
-export declare const checkXPubWithHashes: ({ xpub, path, knownXPubHashes, }: CheckXPubWithHashesParams) => boolean;
-export {};