@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/device/TransportList.js

@@ -1,52 +1,13 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createTransportList = void 0;
-const transport_1 = require("@trezor/transport");
-const constants_1 = require("../constants");
-const tryGetTransport = (transports, name) => transports.find(t => t.name === name);
-const getOrCreateTransport = (transports, transportType, params) => {
-  if (transportType === 'BridgeTransport') {
-    const existing = transports.filter(t => t.name === transportType);
-    return existing.length ? existing : [new transport_1.BridgeTransport({
-      ...params,
-      port: 21328
-    }), new transport_1.BridgeTransport(params)];
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { isTransportInstance } from "@trezor/transport-common";
+const reuseOrUse = (existing, candidate) => existing.find(t => t.name === candidate.name) ?? candidate;
+const resolveOne = (existing, arg) => {
+  if (!isTransportInstance(arg)) {
+    throw ERRORS.TypedError('Runtime', `init({ transports }) entry is not a valid Transport instance`);
   }
-  if (typeof transportType === 'string') {
-    const existing = tryGetTransport(transports, transportType);
-    if (existing) return existing;
-    switch (transportType) {
-      case 'WebUsbTransport':
-        return new transport_1.WebUsbTransport(params);
-      case 'NodeUsbTransport':
-        return new transport_1.NodeUsbTransport(params);
-      case 'UdpTransport':
-        return new transport_1.UdpTransport(params);
-    }
-  } else if (typeof transportType === 'function' && 'prototype' in transportType) {
-    const transportInstance = new transportType(params);
-    if ((0, transport_1.isTransportInstance)(transportInstance)) {
-      return tryGetTransport(transports, transportInstance.name) ?? transportInstance;
-    }
-  } else if ((0, transport_1.isTransportInstance)(transportType)) {
-    const existing = tryGetTransport(transports, transportType.name);
-    if (existing) {
-      return existing;
-    }
-    if (!transportType.getMessage()) {
-      transportType.updateMessages(params.messages);
-    }
-    return transportType;
-  }
-  throw constants_1.ERRORS.TypedError('Runtime', `DeviceList.init: transports[] of unexpected type: ${transportType}`);
-};
-const createTransports = (existing, transports = [], params) => {
-  const transportTypes = transports?.length ? transports : ['BridgeTransport'];
-  return transportTypes.flatMap(type => getOrCreateTransport(existing, type, params));
+  return reuseOrUse(existing, arg);
 };
-const createTransportList = params => (existing, transports) => createTransports(existing, transports, params);
-exports.createTransportList = createTransportList;
-//# sourceMappingURL=TransportList.js.map
+export const createTransportList = (existing, transports) => {
+  if (!transports?.length) return [];
+  return transports.map(transport => resolveOne(existing, transport));
+};

package/lib/device/TransportManager.d.ts

@@ -1,30 +1,33 @@
-import { TRANSPORT, Transport } from '@trezor/transport';
+import { TRANSPORT, type Transport } from '@trezor/transport-common';
 import { TypedEmitter } from '@trezor/utils';
 type TransportManagerEvents = {
-    [TRANSPORT.START]: Transport;
-    [TRANSPORT.ERROR]: string;
+  [TRANSPORT.START]: Transport;
+  [TRANSPORT.ERROR]: string;
 };
 type StartTransport = (transport: Transport, pendingTransportEvent: boolean, signal: AbortSignal) => Promise<void>;
 type InitParams = {
-    transports: Transport[];
-    transportReconnect?: boolean;
-    pendingTransportEvent?: boolean;
+  transports: Transport[];
+  transportReconnect?: boolean;
+  pendingTransportEvent?: boolean;
 };
 export declare class TransportManager extends TypedEmitter<TransportManagerEvents> {
-    private lock;
-    private transports;
-    private activeTransport?;
-    private transportReconnect;
-    private upgradeTimeout?;
-    private readonly startTransport;
-    constructor(startTransport: StartTransport);
-    pending(): Promise<void> | undefined;
-    get(): Transport | undefined;
-    init({ transports, transportReconnect, pendingTransportEvent }: InitParams): Promise<void>;
-    dispose(): Promise<void>;
-    private selectTransport;
-    private scheduleUpgradeCheck;
-    private createInitPromise;
+  private lock;
+  private transports;
+  private activeTransport?;
+  private transportReconnect;
+  private upgradeTimeout?;
+  private readonly startTransport;
+  constructor(startTransport: StartTransport);
+  pending(): Promise<void> | undefined;
+  get(): Transport | undefined;
+  init({
+    transports,
+    transportReconnect,
+    pendingTransportEvent
+  }: InitParams): Promise<void>;
+  dispose(): Promise<void>;
+  private selectTransport;
+  private scheduleUpgradeCheck;
+  private createInitPromise;
 }
-export {};
-//# sourceMappingURL=TransportManager.d.ts.map
+export {};

package/lib/device/TransportManager.js

@@ -1,11 +1,5 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.TransportManager = void 0;
-const transport_1 = require("@trezor/transport");
-const utils_1 = require("@trezor/utils");
+import { TRANSPORT } from "@trezor/transport-common";
+import { TypedEmitter, resolveAfter } from "@trezor/utils";
 const createOverrideLock = () => {
   let promise;
   let sequence = 0;
@@ -32,7 +26,7 @@ const createOverrideLock = () => {
     getPending
   };
 };
-class TransportManager extends utils_1.TypedEmitter {
+export class TransportManager extends TypedEmitter {
   lock = createOverrideLock();
   transports = [];
   activeTransport;
@@ -72,13 +66,15 @@ class TransportManager extends utils_1.TypedEmitter {
       return Promise.resolve();
     });
   }
-  async selectTransport([transport, ...rest], signal) {
+  async selectTransport(transports, signal) {
     if (signal.aborted) throw new Error(signal.reason);
+    const transport = transports[0];
+    const rest = transports.slice(1);
     if (transport === this.activeTransport) return transport;
     const result = await transport.init({
       signal
     });
-    if (result.success) return transport;else if (rest.length) return this.selectTransport(rest, signal);else throw new Error(result.error);
+    if (result.success) return transport;else if (rest.length) return this.selectTransport(rest, signal);else throw new Error(result.error.code);
   }
   scheduleUpgradeCheck(pendingTransportEvent) {
     clearTimeout(this.upgradeTimeout);
@@ -114,37 +110,35 @@ class TransportManager extends utils_1.TypedEmitter {
             transport.stop();
             throw err;
           }
-          transport.on(transport_1.TRANSPORT.ERROR, error => {
-            this.emit(transport_1.TRANSPORT.ERROR, error);
+          transport.on(TRANSPORT.ERROR, error => {
+            this.emit(TRANSPORT.ERROR, error);
             clearTimeout(this.upgradeTimeout);
             this.lock.override('Transport error', async signal => {
               delete this.activeTransport;
               transport.stop();
               if (this.transportReconnect) {
-                await (0, utils_1.resolveAfter)(1000, signal);
+                await resolveAfter(1000, signal);
                 await this.createInitPromise(pendingTransportEvent, signal);
               }
             }).catch(() => {});
           });
           this.activeTransport = transport;
-          this.emit(transport_1.TRANSPORT.START, transport);
+          this.emit(TRANSPORT.START, transport);
         } else {
-          this.emit(transport_1.TRANSPORT.ERROR, 'Transport disabled');
+          this.emit(TRANSPORT.ERROR, 'Transport disabled');
         }
       }
       if (transport && transport !== transports[0]) {
         this.scheduleUpgradeCheck(pendingTransportEvent);
       }
     } catch (error) {
-      this.emit(transport_1.TRANSPORT.ERROR, error?.message);
+      this.emit(TRANSPORT.ERROR, error?.message);
       if (this.transportReconnect && !abortSignal.aborted) {
         this.lock.override('Reconnecting', async signal => {
-          await (0, utils_1.resolveAfter)(1000, signal);
+          await resolveAfter(1000, signal);
           await this.createInitPromise(pendingTransportEvent, signal);
         }).catch(() => {});
       }
     }
   }
-}
-exports.TransportManager = TransportManager;
-//# sourceMappingURL=TransportManager.js.map
+}

package/lib/device/calculateRevisionForDevice.d.ts

@@ -1,8 +1,10 @@
-import { VersionArray } from '@trezor/device-utils';
+import type { VersionArray } from '@trezor/utils/lib/versionUtils';
 type calculateRevisionForDeviceParams = {
-    commitRevision: string;
-    version: VersionArray;
+  commitRevision: string;
+  version: VersionArray;
 };
-export declare const calculateRevisionForDevice: ({ commitRevision, version, }: calculateRevisionForDeviceParams) => string;
-export {};
-//# sourceMappingURL=calculateRevisionForDevice.d.ts.map
+export declare const calculateRevisionForDevice: ({
+  commitRevision,
+  version
+}: calculateRevisionForDeviceParams) => string;
+export {};

package/lib/device/calculateRevisionForDevice.js

@@ -1,27 +1,19 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.calculateRevisionForDevice = void 0;
-const versionUtils_1 = require("@trezor/utils/lib/versionUtils");
-const calculateRevisionForDevice = ({
+import { isNewer } from "@trezor/utils/lib/versionUtils.js";
+export const calculateRevisionForDevice = ({
   commitRevision,
   version
 }) => {
-  if ((0, versionUtils_1.isNewer)(version, '2.4.0')) {
+  if (isNewer(version, '2.4.0')) {
     return commitRevision;
   }
-  if ((0, versionUtils_1.isNewer)(version, '2.2.0')) {
+  if (isNewer(version, '2.2.0')) {
     return commitRevision.slice(0, 9);
   }
-  if ((0, versionUtils_1.isNewer)(version, '2.1.8')) {
+  if (isNewer(version, '2.1.8')) {
     return commitRevision;
   }
-  if ((0, versionUtils_1.isNewer)(version, '2.0.0')) {
+  if (isNewer(version, '2.0.0')) {
     return commitRevision.slice(0, 8);
   }
   return commitRevision;
-};
-exports.calculateRevisionForDevice = calculateRevisionForDevice;
-//# sourceMappingURL=calculateRevisionForDevice.js.map
+};

package/lib/device/checkFirmwareRevision.d.ts

@@ -1,12 +1,22 @@
-import type { FirmwareType, VersionArray } from '@trezor/device-utils';
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import { FirmwareRevisionCheckResult } from '../types/device';
+import type { FirmwareRevisionCheckResult } from '@trezor/connect-common/lib/types/device';
+import type { FirmwareType } from '@trezor/device-utils';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { VersionArray } from '@trezor/utils/lib/versionUtils';
 export type CheckFirmwareRevisionParams = {
-    firmwareVersion: VersionArray;
-    internalModel: PROTO.DeviceModelInternal;
-    deviceRevision: string | null;
-    expectedRevision: string | undefined;
-    firmwareType: FirmwareType;
+  firmwareVersion: VersionArray;
+  internalModel: PROTO.DeviceModelInternal;
+  deviceRevision?: string | null;
+  expectedRevision: string | undefined;
+  deviceBootloaderHash?: string | null;
+  expectedBootloaderHash: string | undefined;
+  firmwareType: FirmwareType;
 };
-export declare const checkFirmwareRevision: ({ firmwareVersion, internalModel, deviceRevision, expectedRevision, firmwareType, }: CheckFirmwareRevisionParams) => Promise<FirmwareRevisionCheckResult>;
-//# sourceMappingURL=checkFirmwareRevision.d.ts.map
+export declare const checkFirmwareRevision: ({
+  firmwareVersion,
+  internalModel,
+  deviceRevision,
+  expectedRevision,
+  deviceBootloaderHash,
+  expectedBootloaderHash,
+  firmwareType
+}: CheckFirmwareRevisionParams) => Promise<FirmwareRevisionCheckResult>;

package/lib/device/checkFirmwareRevision.js

@@ -1,20 +1,34 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.checkFirmwareRevision = void 0;
-const utils_1 = require("@trezor/utils");
-const calculateRevisionForDevice_1 = require("./calculateRevisionForDevice");
-const firmwareInfo_1 = require("../data/firmwareInfo");
-const assetUtils_1 = require("../utils/assetUtils");
-const isNotFoundError = e => e instanceof assetUtils_1.HttpRequestError && e.response.status === 404;
-const isNodeJSOfflineError = e => ['FetchError', 'AbortError'].includes(e.name);
+import { serializeError, versionUtils } from "@trezor/utils";
+import { calculateRevisionForDevice } from "./calculateRevisionForDevice.js";
+import { getOnlineReleaseByVersion } from "../data/firmwareInfo.js";
+import { HttpRequestError } from "../utils/assetUtils.js";
+const isNotFoundError = e => e instanceof HttpRequestError && e.response.status === 404;
+const NODEJS_NETWORK_ERROR_CODES = ['ENOTFOUND', 'ECONNREFUSED', 'ECONNRESET', 'EAI_AGAIN', 'ENETUNREACH', 'EHOSTUNREACH', 'ETIMEDOUT'];
+const getNodeJSErrorCode = e => {
+  if (typeof e !== 'object' || e === null) {
+    return undefined;
+  }
+  if ('code' in e && typeof e.code === 'string') {
+    return e.code;
+  }
+  if ('cause' in e) {
+    return getNodeJSErrorCode(e.cause);
+  }
+  return undefined;
+};
+const isNodeJSOfflineError = e => {
+  if (e instanceof TypeError && e.message.includes('fetch failed')) {
+    return true;
+  }
+  const code = getNodeJSErrorCode(e);
+  return code !== undefined && NODEJS_NETWORK_ERROR_CODES.includes(code);
+};
 const isReactNativeOfflineError = e => e.name === 'TypeError' && e.message.includes('Network request failed');
+const isBrowserOfflineError = e => e instanceof TypeError && e.message.includes('Failed to fetch');
 const isAbortControllerTimeout = e => e.message.includes('Aborted') || e.name === 'AbortError' || e.name === 'TimeoutError' && e.message.includes('signal timed out');
 const isOfflineError = e => {
   if (!(e instanceof Error)) return false;
-  return isNodeJSOfflineError(e) || isReactNativeOfflineError(e) || isAbortControllerTimeout(e);
+  return isNodeJSOfflineError(e) || isReactNativeOfflineError(e) || isBrowserOfflineError(e) || isAbortControllerTimeout(e);
 };
 const failFirmwareRevisionCheck = (error, errorPayload) => ({
   success: false,
@@ -28,31 +42,40 @@ const doRevisionsMatch = ({
   expectedCommitRevision,
   firmwareVersion
 }) => {
-  if (deviceRevision === null) {
+  if (!deviceRevision) {
     return false;
   }
-  const adjustedExpected = (0, calculateRevisionForDevice_1.calculateRevisionForDevice)({
+  const adjustedExpected = calculateRevisionForDevice({
     commitRevision: expectedCommitRevision,
     version: firmwareVersion
   });
   return adjustedExpected === deviceRevision;
 };
-const checkFirmwareRevision = async ({
+export const checkFirmwareRevision = async ({
   firmwareVersion,
   internalModel,
   deviceRevision,
   expectedRevision,
+  deviceBootloaderHash,
+  expectedBootloaderHash,
   firmwareType
 }) => {
+  if (expectedBootloaderHash && deviceBootloaderHash !== expectedBootloaderHash) {
+    return failFirmwareRevisionCheck('bootloader-hash-mismatch');
+  }
   if (expectedRevision === undefined) {
-    if (!utils_1.versionUtils.isVersionArray(firmwareVersion)) {
+    if (!versionUtils.isVersionArray(firmwareVersion)) {
       return failFirmwareRevisionCheck('firmware-version-unknown');
     }
     try {
-      const onlineRelease = await (0, firmwareInfo_1.getOnlineReleaseByVersion)(internalModel, firmwareVersion, firmwareType);
+      const onlineRelease = await getOnlineReleaseByVersion(internalModel, firmwareVersion, firmwareType);
       if (onlineRelease?.firmware_revision === undefined) {
         return failFirmwareRevisionCheck('firmware-version-unknown');
       }
+      const expectedOnlineBootloaderHash = onlineRelease.bootloader_hash;
+      if (expectedOnlineBootloaderHash && deviceBootloaderHash !== expectedOnlineBootloaderHash) {
+        return failFirmwareRevisionCheck('bootloader-hash-mismatch');
+      }
       if (!doRevisionsMatch({
         deviceRevision,
         expectedCommitRevision: onlineRelease.firmware_revision,
@@ -65,7 +88,7 @@ const checkFirmwareRevision = async ({
       };
     } catch (e) {
       if (isNotFoundError(e)) return failFirmwareRevisionCheck('firmware-version-unknown');
-      return isOfflineError(e) ? failFirmwareRevisionCheck('cannot-perform-check-offline') : failFirmwareRevisionCheck('other-error', (0, utils_1.serializeError)(e));
+      return isOfflineError(e) ? failFirmwareRevisionCheck('cannot-perform-check-offline') : failFirmwareRevisionCheck('other-error', serializeError(e));
     }
   }
   if (!doRevisionsMatch({
@@ -78,6 +101,4 @@ const checkFirmwareRevision = async ({
   return {
     success: true
   };
-};
-exports.checkFirmwareRevision = checkFirmwareRevision;
-//# sourceMappingURL=checkFirmwareRevision.js.map
+};

package/lib/device/resolveDescriptorForTaproot.d.ts

@@ -1,15 +1,17 @@
-import { MessagesSchema as Messages } from '@trezor/protobuf';
-import { HDNodeResponse } from '../types/api/getPublicKey';
+import type { HDNodeResponse } from '@trezor/connect-common/lib/types/api/account/getPublicKey';
+import type { MessagesSchema as Messages } from '@trezor/protobuf';
 interface ResolveDescriptorForTaprootParams {
-    response: HDNodeResponse;
-    publicKey: Messages.PublicKey;
+  response: HDNodeResponse;
+  publicKey: Messages.PublicKey;
 }
-export declare const resolveDescriptorForTaproot: ({ response, publicKey, }: ResolveDescriptorForTaprootParams) => {
-    xpub: string;
-    checksum: string;
+export declare const resolveDescriptorForTaproot: ({
+  response,
+  publicKey
+}: ResolveDescriptorForTaprootParams) => {
+  xpub: string;
+  checksum: string;
 } | {
-    xpub: string;
-    checksum: undefined;
+  xpub: string;
+  checksum: undefined;
 };
-export {};
-//# sourceMappingURL=resolveDescriptorForTaproot.d.ts.map
+export {};

package/lib/device/resolveDescriptorForTaproot.js

@@ -1,21 +1,17 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.resolveDescriptorForTaproot = void 0;
-const utils_1 = require("@trezor/utils");
-const resolveDescriptorForTaproot = ({
+import { convertTaprootXpub, isNotNull, isNotNullOrUndefined } from "@trezor/utils";
+export const resolveDescriptorForTaproot = ({
   response,
   publicKey
 }) => {
-  if (publicKey.descriptor !== null && publicKey.descriptor !== undefined) {
-    const [xpub, checksum] = publicKey.descriptor.split('#');
-    const correctedXpub = (0, utils_1.convertTaprootXpub)({
+  if (isNotNullOrUndefined(publicKey.descriptor)) {
+    const splittedDescriptor = publicKey.descriptor.split('#');
+    const xpub = splittedDescriptor[0];
+    const checksum = splittedDescriptor[1];
+    const correctedXpub = convertTaprootXpub({
       xpub,
       direction: 'h-to-apostrophe'
     });
-    if (correctedXpub !== null) {
+    if (isNotNull(correctedXpub)) {
       return {
         xpub: correctedXpub,
         checksum
@@ -28,6 +24,4 @@ const resolveDescriptorForTaproot = ({
     xpub: `tr([${descriptorPath}]${response.xpub}/<0;1>/*)`,
     checksum: undefined
   };
-};
-exports.resolveDescriptorForTaproot = resolveDescriptorForTaproot;
-//# sourceMappingURL=resolveDescriptorForTaproot.js.map
+};

package/lib/device/thp/handshake.d.ts

@@ -1,4 +1,3 @@
-import type { Device } from '../Device';
-export declare const createThpChannel: (device: Device) => Promise<void>;
-export declare const thpHandshake: (device: Device, unlockPin?: boolean) => Promise<void>;
-//# sourceMappingURL=handshake.d.ts.map
+import type { IDevice } from "../../types/idevice.js";
+export declare const createThpChannel: (device: IDevice) => Promise<void>;
+export declare const thpHandshake: (device: IDevice, unlockPin?: boolean) => Promise<void>;

package/lib/device/thp/handshake.js

@@ -1,28 +1,22 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.thpHandshake = exports.createThpChannel = void 0;
-const crypto_1 = require("crypto");
-const protobuf_1 = require("@trezor/protobuf");
-const protocol_1 = require("@trezor/protocol");
-const thpCall_1 = require("./thpCall");
-const constants_1 = require("../../constants");
-const DataManager_1 = require("../../data/DataManager");
+import { randomBytes } from "@noble/hashes/utils.js";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { protobufManager } from "@trezor/protobuf";
+import { thp as protocolThp } from "@trezor/protocol";
+import { thpCall } from "./thpCall.js";
+import * as settingsStore from "../../data/settingsStore.js";
 const getPairingMethods = (deviceMethods, settingsMethods) => deviceMethods?.flatMap(dm => {
-  const value = protocol_1.thp.getThpPairingMethod(dm);
-  const isRequested = settingsMethods && settingsMethods.find(sm => value === protocol_1.thp.getThpPairingMethod(sm));
+  const value = protocolThp.getThpPairingMethod(dm);
+  const isRequested = settingsMethods?.find(sm => value === protocolThp.getThpPairingMethod(sm));
   return isRequested ? value : [];
 });
-const createThpChannel = async device => {
+export const createThpChannel = async device => {
   const thpState = device.getThpState();
   if (!thpState) {
-    throw constants_1.ERRORS.TypedError('Device_ThpStateMissing');
+    throw ERRORS.TypedError('Device_ThpStateMissing');
   }
-  thpState.setChannel(protocol_1.thp.constants.THP_DEFAULT_CHANNEL);
-  const nonce = (0, crypto_1.randomBytes)(8);
-  const createChannel = await (0, thpCall_1.thpCall)(device, 'ThpCreateChannelRequest', {
+  thpState.setChannel(protocolThp.constants.THP_DEFAULT_CHANNEL);
+  const nonce = Buffer.from(randomBytes(8));
+  const createChannel = await thpCall(device, 'ThpCreateChannelRequest', {
     nonce
   });
   const {
@@ -32,10 +26,10 @@ const createThpChannel = async device => {
   if (nonce.compare(resp.nonce) !== 0) {
     throw new Error('Nonce not meet' + nonce.toString('hex') + ' ' + resp.nonce.toString('hex'));
   }
-  const settings = DataManager_1.DataManager.getSettings('thp');
+  const settings = settingsStore.get('thp');
   const pairingMethods = getPairingMethods(properties.pairing_methods, settings?.pairingMethods);
   if (!pairingMethods?.length) {
-    throw constants_1.ERRORS.TypedError('Device_ThpPairingMethodsException');
+    throw ERRORS.TypedError('Device_ThpPairingMethodsException');
   }
   thpState.setThpProperties(properties);
   thpState.setChannel(resp.channel);
@@ -44,33 +38,29 @@ const createThpChannel = async device => {
     handshakeHash: resp.handshakeHash
   });
 };
-exports.createThpChannel = createThpChannel;
-const thpHandshake = async (device, unlockPin = false) => {
+export const thpHandshake = async (device, unlockPin = false) => {
   const thpState = device.getThpState();
   if (!thpState?.handshakeCredentials) {
-    throw constants_1.ERRORS.TypedError('Device_ThpStateMissing');
+    throw ERRORS.TypedError('Device_ThpStateMissing');
   }
-  const settings = DataManager_1.DataManager.getSettings('thp');
-  const staticKey = settings?.staticKey ? Buffer.from(settings.staticKey, 'hex') : (0, crypto_1.randomBytes)(32);
-  const hostStaticKeys = protocol_1.thp.getCurve25519KeyPair(staticKey);
+  const settings = settingsStore.get('thp');
   const knownCredentials = (settings?.knownCredentials || []).sort(cre => cre.autoconnect ? -1 : 1);
   const tryToUnlock = unlockPin ? 1 : 0;
-  const hostEphemeralKeys = protocol_1.thp.getCurve25519KeyPair((0, crypto_1.randomBytes)(32));
-  const handshakeInit = await (0, thpCall_1.thpCall)(device, 'ThpHandshakeInitRequest', {
+  const hostEphemeralKeys = protocolThp.getCurve25519KeyPair(Buffer.from(randomBytes(32)));
+  const handshakeInit = await thpCall(device, 'ThpHandshakeInitRequest', {
     key: hostEphemeralKeys.publicKey,
     tryToUnlock
   });
   const {
     trezorEncryptedStaticPubkey
   } = handshakeInit.message;
-  const handshakeCredentials = protocol_1.thp.handleHandshakeInit({
+  const handshakeCredentials = protocolThp.handleHandshakeInit({
     handshakeInitResponse: handshakeInit.message,
     thpState,
-    hostStaticKeys,
     hostEphemeralKeys,
     knownCredentials,
     tryToUnlock,
-    protobufEncoder: (name, data) => (0, protobuf_1.encodeMessage)(device.transport.getMessages(), name, data)
+    protobufEncoder: (name, data) => protobufManager.encode(name, data)
   });
   const {
     hostKey,
@@ -83,11 +73,11 @@ const thpHandshake = async (device, unlockPin = false) => {
     handshakeHash: handshakeCredentials.handshakeHash,
     trezorKey,
     hostKey,
-    staticKey,
-    hostStaticPublicKey: hostStaticKeys.publicKey
+    staticKey: handshakeCredentials.staticKey,
+    hostStaticPublicKey: handshakeCredentials.hostStaticKeys.publicKey
   });
   thpState.setPairingCredentials(handshakeCredentials.allCredentials);
-  const handshakeCompletion = await (0, thpCall_1.thpCall)(device, 'ThpHandshakeCompletionRequest', {
+  const handshakeCompletion = await thpCall(device, 'ThpHandshakeCompletionRequest', {
     hostPubkey: hostEncryptedStaticPubkey,
     encryptedPayload: handshakeCredentials.encryptedPayload
   });
@@ -104,9 +94,7 @@ const thpHandshake = async (device, unlockPin = false) => {
   thpState.setIsPaired(handshakeCompletion.message.state !== 0);
   thpState.setPhase('pairing');
   if (thpState.isAutoconnectPaired || handshakeCompletion.message.state === 2) {
-    await (0, thpCall_1.thpCall)(device, 'ThpEndRequest', {});
+    await thpCall(device, 'ThpEndRequest', {});
     thpState.setPhase('paired');
   }
-};
-exports.thpHandshake = thpHandshake;
-//# sourceMappingURL=handshake.js.map
+};

package/lib/device/thp/index.d.ts

@@ -1,6 +1,5 @@
-import type { Device } from '../Device';
-export { abortThpWorkflow } from './thpCall';
-export { getThpCredentials } from './pairing';
-export { createThpSession } from './session';
-export declare const getThpChannel: (device: Device, withInteraction?: boolean) => Promise<"pin-locked" | "thp-locked" | undefined>;
-//# sourceMappingURL=index.d.ts.map
+import type { IDevice } from "../../types/idevice.js";
+export { abortThpWorkflow } from "./thpCall.js";
+export { getThpCredentials } from "./pairing.js";
+export { createThpSession } from "./session.js";
+export declare const getThpChannel: (device: IDevice, withInteraction?: boolean) => Promise<"pin-locked" | "thp-locked" | undefined>;