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

package/lib/api/getFeatures.d.ts

@@ -0,0 +1,71 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class GetFeatures extends AbstractMethod<'getFeatures'> {
+  constructor(message: MethodMessage<'getFeatures'>);
+  get requiredPermissions(): PermissionRequest[];
+  checkFirmwareRange(): undefined;
+  run(): Promise<{
+    label?: string | null | undefined;
+    session_id?: string | null | undefined;
+    language?: string | null | undefined;
+    auto_lock_delay_ms?: number | null | undefined;
+    display_rotation?: "North" | "East" | "South" | "West" | null | undefined;
+    passphrase_always_on_device?: boolean | null | undefined;
+    safety_checks?: "Strict" | "PromptAlways" | "PromptTemporarily" | null | undefined;
+    experimental_features?: boolean | null | undefined;
+    hide_passphrase_from_host?: boolean | undefined;
+    haptic_feedback?: boolean | undefined;
+    auto_lock_delay_battery_ms?: number | undefined;
+    flags?: number | null | undefined;
+    passphrase_protection?: boolean | null | undefined;
+    no_backup?: boolean | null | undefined;
+    unfinished_backup?: boolean | null | undefined;
+    pin_protection?: boolean | null | undefined;
+    backup_type?: "Bip39" | "Slip39_Basic" | "Slip39_Advanced" | "Slip39_Single_Extendable" | "Slip39_Basic_Extendable" | "Slip39_Advanced_Extendable" | null | undefined;
+    vendor?: string | undefined;
+    build_version?: number | undefined;
+    bootloader_mode?: boolean | null | undefined;
+    initialized?: boolean | null | undefined;
+    revision?: string | null | undefined;
+    bootloader_hash?: string | null | undefined;
+    imported?: boolean | null | undefined;
+    unlocked?: boolean | null | undefined;
+    _passphrase_cached?: boolean | undefined;
+    firmware_present?: boolean | null | undefined;
+    backup_availability?: "NotAvailable" | "Required" | "Available" | null | undefined;
+    fw_major?: number | null | undefined;
+    fw_minor?: number | null | undefined;
+    fw_patch?: number | null | undefined;
+    fw_build?: number | undefined;
+    fw_vendor?: string | null | undefined;
+    recovery_status?: "Nothing" | "Recovery" | "Backup" | null | undefined;
+    sd_card_present?: boolean | null | undefined;
+    sd_protection?: boolean | null | undefined;
+    wipe_code_protection?: boolean | null | undefined;
+    busy?: boolean | undefined;
+    homescreen_format?: "Toif" | "Jpeg" | "ToiG" | null | undefined;
+    unit_color?: number | undefined;
+    unit_btconly?: boolean | undefined;
+    homescreen_width?: number | undefined;
+    homescreen_height?: number | undefined;
+    bootloader_locked?: boolean | undefined;
+    language_version_matches?: boolean | undefined;
+    unit_packaging?: number | undefined;
+    recovery_type?: "NormalRecovery" | "DryRun" | "UnlockRepeatedBackup" | null | undefined;
+    optiga_sec?: number | undefined;
+    soc?: number | undefined;
+    firmware_corrupted?: boolean | undefined;
+    led?: boolean | undefined;
+    usb_connected?: boolean | undefined;
+    wireless_connected?: boolean | undefined;
+    tap_to_wake?: boolean | undefined;
+    capabilities: ("Capability_Bitcoin" | "Capability_Bitcoin_like" | "Capability_Binance" | "Capability_Cardano" | "Capability_Crypto" | "Capability_EOS" | "Capability_Ethereum" | "Capability_Lisk" | "Capability_Monero" | "Capability_NEM" | "Capability_Ripple" | "Capability_Stellar" | "Capability_Tezos" | "Capability_U2F" | "Capability_Shamir" | "Capability_ShamirGroups" | "Capability_PassphraseEntry" | "Capability_Solana" | "Capability_Translations" | "Capability_Brightness" | "Capability_Haptic" | "Capability_BLE" | "Capability_NFC" | "Capability_Tron" | "Capability_N4W1" | "Capability_TouchWakeup")[];
+    model: string;
+    major_version: number;
+    minor_version: number;
+    patch_version: number;
+    device_id: string | null;
+    internal_model: import("@trezor/protobuf/lib/definitions").DeviceModelInternal;
+  }>;
+}

package/lib/api/getFeatures.js

@@ -0,0 +1,22 @@
+import { UI_REQUEST } from "@trezor/connect-common";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class GetFeatures extends AbstractMethod {
+  constructor(message) {
+    super(message, undefined);
+    this.useUi = false;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE, UI_REQUEST.BOOTLOADER];
+    this.useDeviceState = false;
+    this.useEmptyPassphrase = true;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'read_features'
+    }];
+  }
+  checkFirmwareRange() {
+    return undefined;
+  }
+  run() {
+    return Promise.resolve(this.getDevice().features);
+  }
+}

package/lib/api/getFirmwareHash.d.ts

@@ -0,0 +1,11 @@
+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 GetFirmwareHash extends AbstractMethod<'getFirmwareHash', PROTO.GetFirmwareHash> {
+  constructor(message: MethodMessage<'getFirmwareHash'>);
+  get requiredPermissions(): PermissionRequest[];
+  run(): Promise<{
+    hash: string;
+  }>;
+}

package/lib/api/getFirmwareHash.js

@@ -0,0 +1,29 @@
+import { UI_REQUEST } from "@trezor/connect-common";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class GetFirmwareHash extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(PROTO.GetFirmwareHash, payload);
+    const params = {
+      challenge: payload.challenge
+    };
+    super(message, params);
+    this.useEmptyPassphrase = true;
+    this.useDeviceState = false;
+    this.allowDeviceMode = [UI_REQUEST.INITIALIZE];
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('GetFirmwareHash', 'FirmwareHash', this.params);
+    return response.message;
+  }
+}

package/lib/api/getNonce.d.ts

@@ -0,0 +1,10 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class GetNonce extends AbstractMethod<'getNonce'> {
+  constructor(message: MethodMessage<'getNonce'>);
+  get requiredPermissions(): PermissionRequest[];
+  run(): Promise<{
+    nonce: string;
+  }>;
+}

package/lib/api/getNonce.js

@@ -0,0 +1,18 @@
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class GetNonce extends AbstractMethod {
+  constructor(message) {
+    super(message, undefined);
+    this.useDeviceState = false;
+    this.useEmptyPassphrase = true;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('GetNonce', 'Nonce');
+    return response.message;
+  }
+}

package/lib/api/getOwnershipId.d.ts

@@ -0,0 +1,17 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodContext, MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class GetOwnershipId extends AbstractMethod<'getOwnershipId', PROTO.GetOwnershipId[]> {
+  constructor(message: MethodMessage<'getOwnershipId'>);
+  hasBundle?: boolean;
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  get confirmation(): {
+    view: "export-address";
+    label: string;
+  };
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<import("@trezor/connect-common/lib/types/api/device/getOwnershipId").OwnershipId | import("@trezor/connect-common/lib/types/api/device/getOwnershipId").OwnershipId[]>;
+}

package/lib/api/getOwnershipId.js

@@ -0,0 +1,88 @@
+import { Bundle, GetOwnershipId as GetOwnershipIdSchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { Assert } from "@trezor/schema-utils";
+import { bundlify } from "./common/paramsValidator.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { getBitcoinNetwork } from "../data/coinInfo.js";
+import { getScriptType, getSerializedPath, validatePath } from "../utils/pathUtils.js";
+export default class GetOwnershipId extends AbstractMethod {
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(GetOwnershipIdSchema), payload);
+    const preprocessed = payload.bundle.map(batch => {
+      const address_n = validatePath(batch.path, 1);
+      const coinInfo = getBitcoinNetwork(batch.coin || address_n);
+      if (batch.coin && !coinInfo) {
+        throw ERRORS.TypedError('Method_UnknownCoin');
+      }
+      return {
+        batch,
+        address_n,
+        coinInfo
+      };
+    });
+    const params = preprocessed.map(({
+      batch,
+      address_n,
+      coinInfo
+    }) => {
+      const script_type = batch.scriptType || getScriptType(address_n);
+      return {
+        address_n,
+        coin_name: coinInfo ? coinInfo.name : undefined,
+        multisig: batch.multisig,
+        script_type
+      };
+    });
+    super(message, params);
+    this.requiredFirmwareCoins = preprocessed.map(({
+      coinInfo
+    }) => coinInfo);
+    this.hasBundle = hasBundle;
+  }
+  hasBundle;
+  get requiredPermissions() {
+    return this.coinPerms('read_account_info', this.requiredFirmwareCoins);
+  }
+  get info() {
+    return 'Export ownership id';
+  }
+  get confirmation() {
+    return {
+      view: 'export-address',
+      label: this.params.length > 1 ? 'Export multiple ownership proof ids' : this.info
+    };
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const responses = [];
+    const cmd = this.getDevice().getCommands();
+    for (let i = 0; i < this.params.length; i++) {
+      const {
+        params
+      } = this;
+      const batch = params[i];
+      const {
+        message
+      } = await cmd.typedCall('GetOwnershipId', 'OwnershipId', batch);
+      responses.push({
+        ...message,
+        path: batch.address_n,
+        serializedPath: getSerializedPath(batch.address_n)
+      });
+      if (this.hasBundle) {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
+          total: this.params.length,
+          progress: i,
+          response: message
+        }));
+      }
+    }
+    const first = responses[0];
+    return this.hasBundle ? responses : first;
+  }
+}

package/lib/api/getOwnershipProof.d.ts

@@ -0,0 +1,17 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodContext, MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class GetOwnershipProof extends AbstractMethod<'getOwnershipProof', PROTO.GetOwnershipProof[]> {
+  constructor(message: MethodMessage<'getOwnershipProof'>);
+  hasBundle?: boolean;
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  get confirmation(): {
+    view: "export-address";
+    label: string;
+  };
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<import("@trezor/connect-common/lib/types/api/device/getOwnershipProof").OwnershipProof | import("@trezor/connect-common/lib/types/api/device/getOwnershipProof").OwnershipProof[]>;
+}

package/lib/api/getOwnershipProof.js

@@ -0,0 +1,95 @@
+import { Bundle, GetOwnershipProof as GetOwnershipProofSchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { Assert } from "@trezor/schema-utils";
+import { bundlify } from "./common/paramsValidator.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { getBitcoinNetwork } from "../data/coinInfo.js";
+import { getScriptType, getSerializedPath, validatePath } from "../utils/pathUtils.js";
+export default class GetOwnershipProof extends AbstractMethod {
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(GetOwnershipProofSchema), payload);
+    const preprocessed = payload.bundle.map(batch => {
+      const address_n = validatePath(batch.path, 1);
+      const coinInfo = getBitcoinNetwork(batch.coin || address_n);
+      if (batch.coin && !coinInfo) {
+        throw ERRORS.TypedError('Method_UnknownCoin');
+      }
+      return {
+        batch,
+        address_n,
+        coinInfo
+      };
+    });
+    const params = preprocessed.map(({
+      batch,
+      address_n,
+      coinInfo
+    }) => {
+      const script_type = batch.scriptType || getScriptType(address_n);
+      return {
+        address_n,
+        coin_name: coinInfo ? coinInfo.name : undefined,
+        multisig: batch.multisig,
+        script_type,
+        user_confirmation: batch.userConfirmation,
+        ownership_ids: batch.ownershipIds,
+        commitment_data: batch.commitmentData
+      };
+    });
+    super(message, params);
+    this.requiredFirmwareCoins = preprocessed.map(({
+      coinInfo
+    }) => coinInfo);
+    this.preauthorized = payload.bundle.some(batch => batch.preauthorized);
+    this.hasBundle = hasBundle;
+  }
+  hasBundle;
+  get requiredPermissions() {
+    return this.coinPerms('read_account_info', this.requiredFirmwareCoins);
+  }
+  get info() {
+    return 'Export ownership proof';
+  }
+  get confirmation() {
+    return {
+      view: 'export-address',
+      label: this.params.length > 1 ? 'Export multiple ownership proofs' : this.info
+    };
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const responses = [];
+    const cmd = this.getDevice().getCommands();
+    for (let i = 0; i < this.params.length; i++) {
+      const {
+        params
+      } = this;
+      const batch = params[i];
+      if (this.preauthorized) {
+        await cmd.preauthorize(true);
+      }
+      const {
+        message
+      } = await cmd.typedCall('GetOwnershipProof', 'OwnershipProof', batch);
+      responses.push({
+        ...message,
+        path: batch.address_n,
+        serializedPath: getSerializedPath(batch.address_n)
+      });
+      if (this.hasBundle) {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
+          total: this.params.length,
+          progress: i,
+          response: message
+        }));
+      }
+    }
+    const first = responses[0];
+    return this.hasBundle ? responses : first;
+  }
+}

package/lib/api/getPublicKey.d.ts

@@ -0,0 +1,54 @@
+import type { BitcoinNetworkInfo, PermissionRequest } from '@trezor/connect-common';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodContext, MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+type Params = {
+  proto: PROTO.GetPublicKey;
+  coinInfo: BitcoinNetworkInfo;
+  suppressBackupWarning?: boolean;
+  unlockPath?: PROTO.UnlockPath;
+};
+export default class GetPublicKey extends AbstractMethod<'getPublicKey', Params[]> {
+  constructor(message: MethodMessage<'getPublicKey'>);
+  hasBundle?: boolean;
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  get confirmation(): {
+    view: "export-xpub";
+    label: string;
+  };
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<({
+    publicKey: string;
+    path: number[];
+    serializedPath: string;
+    displayablePublicKey: string;
+  } & {
+    xpubSegwit?: string | undefined;
+    descriptorChecksum?: string | undefined;
+    rootFingerprint?: number | undefined;
+    descriptor?: string | undefined;
+    childNum: number;
+    xpub: string;
+    chainCode: string;
+    fingerprint: number;
+    depth: number;
+  }) | ({
+    publicKey: string;
+    path: number[];
+    serializedPath: string;
+    displayablePublicKey: string;
+  } & {
+    xpubSegwit?: string | undefined;
+    descriptorChecksum?: string | undefined;
+    rootFingerprint?: number | undefined;
+    descriptor?: string | undefined;
+    childNum: number;
+    xpub: string;
+    chainCode: string;
+    fingerprint: number;
+    depth: number;
+  })[]>;
+}
+export {};

package/lib/api/getPublicKey.js

@@ -0,0 +1,106 @@
+import { Bundle, GetPublicKey as GetPublicKeySchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { getBitcoinNetwork } from "../data/coinInfo.js";
+import { bundlify, validateCoinPath } from "./common/paramsValidator.js";
+import { getPublicKeyLabel } from "../utils/accountUtils.js";
+import { validatePath } from "../utils/pathUtils.js";
+export default class GetPublicKey extends AbstractMethod {
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(GetPublicKeySchema), payload);
+    const params = payload.bundle.map(batch => {
+      let coinInfo;
+      if (batch.coin) {
+        coinInfo = getBitcoinNetwork(batch.coin);
+      }
+      const address_n = validatePath(batch.path, coinInfo ? 3 : 0);
+      if (coinInfo && !batch.crossChain) {
+        validateCoinPath(address_n, coinInfo);
+      } else if (!coinInfo) {
+        coinInfo = getBitcoinNetwork(address_n);
+      }
+      if (!coinInfo) {
+        throw ERRORS.TypedError('Method_UnknownCoin');
+      }
+      const proto = {
+        address_n,
+        coin_name: coinInfo.name,
+        show_display: batch.showOnTrezor,
+        script_type: batch.scriptType,
+        ignore_xpub_magic: batch.ignoreXpubMagic,
+        ecdsa_curve_name: batch.ecdsaCurveName
+      };
+      return {
+        proto,
+        coinInfo,
+        unlockPath: batch.unlockPath,
+        suppressBackupWarning: batch.suppressBackupWarning
+      };
+    });
+    super(message, params);
+    this.requiredFirmwareCoins = params.map(({
+      coinInfo
+    }) => coinInfo);
+    this.hasBundle = hasBundle;
+    this.confirmMissingBackup = !this.params.every(batch => batch.suppressBackupWarning || !batch.proto.show_display);
+  }
+  hasBundle;
+  get requiredPermissions() {
+    return this.coinPerms('read_xpub', this.requiredFirmwareCoins);
+  }
+  get info() {
+    return 'Export public key';
+  }
+  get confirmation() {
+    if (this.params.length > 1) {
+      return {
+        view: 'export-xpub',
+        label: 'Export multiple public keys'
+      };
+    }
+    const {
+      params
+    } = this;
+    const first = params[0];
+    return {
+      view: 'export-xpub',
+      label: getPublicKeyLabel(first.proto.address_n, first.coinInfo)
+    };
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const responses = [];
+    const cmd = this.getDevice().getCommands();
+    for (let i = 0; i < this.params.length; i++) {
+      const {
+        params
+      } = this;
+      const batch = params[i];
+      const {
+        coinInfo,
+        unlockPath,
+        proto
+      } = batch;
+      const response = await cmd.getHDNode(proto, {
+        coinInfo,
+        unlockPath
+      });
+      responses.push(response);
+      if (this.hasBundle) {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
+          total: this.params.length,
+          progress: i,
+          response
+        }));
+      }
+    }
+    const first = responses[0];
+    return this.hasBundle ? responses : first;
+  }
+}

package/lib/api/getSettings.d.ts

@@ -0,0 +1,24 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class GetSettings extends AbstractMethod<'getSettings'> {
+  constructor(message: MethodMessage<'getSettings'>);
+  get requiredPermissions(): PermissionRequest[];
+  run(): Promise<{
+    enabledNetworks: import("@trezor/connect-common").EnabledNetwork[];
+    manifest?: import("@trezor/connect-common").Manifest;
+    debug?: boolean;
+    createLogger?: import("@trezor/connect-common").CreateLogger;
+    transportReconnect?: boolean;
+    transports?: import("@trezor/connect-common").ConnectSettingsTransport[];
+    pendingTransportEvent?: boolean;
+    binFilesBaseUrl?: string;
+    enableFirmwareHashCheck?: boolean;
+    firmwareHashCheckTimeouts?: import("@trezor/connect-common").FirmwareHashCheckTimeouts;
+    firmwareChannel?: import("@trezor/connect-common").FirmwareChannel;
+    definitionsChannel?: import("@trezor/connect-common").DefinitionsChannel;
+    localFirmwares?: import("@trezor/connect-common").LocalFirmwares;
+    thp?: import("@trezor/connect-common").ThpSettings;
+    requestedPermissions?: PermissionRequest[];
+  }>;
+}

package/lib/api/getSettings.js

@@ -0,0 +1,21 @@
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import * as enabledNetworksStore from "../data/enabledNetworksStore.js";
+import * as settingsStore from "../data/settingsStore.js";
+export default class GetSettings extends AbstractMethod {
+  constructor(message) {
+    super(message, undefined);
+    this.useDevice = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
+  }
+  run() {
+    return Promise.resolve({
+      ...settingsStore.get(),
+      enabledNetworks: enabledNetworksStore.get()
+    });
+  }
+}

package/lib/api/index.d.ts

@@ -0,0 +1,62 @@
+export { default as applyFlags } from "./applyFlags.js";
+export { default as applySettings } from "./applySettings.js";
+export { default as authenticateDevice } from "./authenticateDevice.js";
+export { default as authorizeCoinjoin } from "./authorizeCoinjoin.js";
+export { default as cancelCoinjoinAuthorization } from "./cancelCoinjoinAuthorization.js";
+export { default as showDeviceTutorial } from "./showDeviceTutorial.js";
+export { default as backupDevice } from "./backupDevice.js";
+export { default as bleUnpair } from "./bleUnpair.js";
+export { default as blockchainDisconnect } from "./blockchainDisconnect.js";
+export { default as blockchainEstimateFee } from "./blockchainEstimateFee.js";
+export { default as blockchainGetAccountBalanceHistory } from "./blockchainGetAccountBalanceHistory.js";
+export { default as blockchainGetCurrentFiatRates } from "./blockchainGetCurrentFiatRates.js";
+export { default as blockchainGetContractInfo } from "./blockchainGetContractInfo.js";
+export { default as blockchainGetInfo } from "./blockchainGetInfo.js";
+export { default as blockchainEvmRpcCall } from "./blockchainEvmRpcCall.js";
+export { default as blockchainGetFiatRatesForTimestamps } from "./blockchainGetFiatRatesForTimestamps.js";
+export { default as blockchainGetTransactions } from "./blockchainGetTransactions.js";
+export { default as blockchainSetCustomBackend } from "./blockchainSetCustomBackend.js";
+export { default as blockchainSubscribe } from "./blockchainSubscribe.js";
+export { default as blockchainSubscribeFiatRates } from "./blockchainSubscribeFiatRates.js";
+export { default as blockchainUnsubscribe } from "./blockchainUnsubscribe.js";
+export { default as blockchainUnsubscribeFiatRates } from "./blockchainUnsubscribeFiatRates.js";
+export { default as blockchainValidateEvmRpcUrl } from "./blockchainValidateEvmRpcUrl.js";
+export { default as changeLanguage } from "./changeLanguage.js";
+export { default as changePin } from "./changePin.js";
+export { default as changeWipeCode } from "./changeWipeCode.js";
+export { default as cipherKeyValue } from "./cipherKeyValue.js";
+export { default as evoluGetNode } from "./evoluGetNode.js";
+export { default as evoluSignRegistrationRequest } from "./evoluSignRegistrationRequest.js";
+export { default as evoluGetDelegatedIdentityKey } from "./evoluGetDelegatedIdentityKey.js";
+export { default as nostrGetPublicKey } from "./nostr/nostrGetPublicKey.js";
+export { default as nostrSignEvent } from "./nostr/nostrSignEvent.js";
+export { default as composeTransaction } from "./composeTransaction.js";
+export { default as discoverAccounts } from "./discoverAccounts.js";
+export { default as getAccountInfo } from "./getAccountInfo.js";
+export { default as getAddress } from "./getAddress.js";
+export { default as getCoinInfo } from "./getCoinInfo.js";
+export { default as getDeviceState } from "./getDeviceState.js";
+export { default as getFeatures } from "./getFeatures.js";
+export { default as getFirmwareHash } from "./getFirmwareHash.js";
+export { default as getNonce } from "./getNonce.js";
+export { default as getOwnershipId } from "./getOwnershipId.js";
+export { default as getOwnershipProof } from "./getOwnershipProof.js";
+export { default as getPublicKey } from "./getPublicKey.js";
+export { default as getSettings } from "./getSettings.js";
+export { default as pingDevice } from "./pingDevice.js";
+export { default as pushTransaction } from "./pushTransaction.js";
+export { default as recoveryDevice } from "./recoveryDevice.js";
+export { default as requestLogin } from "./requestLogin.js";
+export { default as resetDevice } from "./resetDevice.js";
+export { default as loadDevice } from "./loadDevice.js";
+export { default as selectAccount } from "./selectAccount.js";
+export { default as setBrightness } from "./setBrightness.js";
+export { default as setBusy } from "./setBusy.js";
+export { default as signMessage } from "./signMessage.js";
+export { default as signTransaction } from "./signTransaction.js";
+export { default as unlockPath } from "./unlockPath.js";
+export { default as telemetryGet } from "./telemetryGet.js";
+export { default as thpGetCredentials } from "./thpGetCredentials.js";
+export { default as thpRemoveCredentials } from "./thpRemoveCredentials.js";
+export { default as verifyMessage } from "./verifyMessage.js";
+export { default as wipeDevice } from "./wipeDevice.js";