@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/device/thp/index.js

@@ -1,41 +1,17 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getThpChannel = exports.createThpSession = exports.getThpCredentials = exports.abortThpWorkflow = void 0;
-const device_1 = require("../../events/device");
-const handshake_1 = require("./handshake");
-const pairing_1 = require("./pairing");
-var thpCall_1 = require("./thpCall");
-Object.defineProperty(exports, "abortThpWorkflow", {
-  enumerable: true,
-  get: function () {
-    return thpCall_1.abortThpWorkflow;
-  }
-});
-var pairing_2 = require("./pairing");
-Object.defineProperty(exports, "getThpCredentials", {
-  enumerable: true,
-  get: function () {
-    return pairing_2.getThpCredentials;
-  }
-});
-var session_1 = require("./session");
-Object.defineProperty(exports, "createThpSession", {
-  enumerable: true,
-  get: function () {
-    return session_1.createThpSession;
-  }
-});
-const getThpChannel = async (device, withInteraction) => {
+import { DEVICE } from "@trezor/connect-common";
+import { createThpChannel, thpHandshake } from "./handshake.js";
+import { thpPairing } from "./pairing.js";
+export { abortThpWorkflow } from "./thpCall.js";
+export { getThpCredentials } from "./pairing.js";
+export { createThpSession } from "./session.js";
+export const getThpChannel = async (device, withInteraction) => {
   const thpState = device.getThpState();
   if (!thpState) return;
   try {
     if (thpState.phase === 'handshake') {
-      await (0, handshake_1.createThpChannel)(device);
+      await createThpChannel(device);
       try {
-        await (0, handshake_1.thpHandshake)(device);
+        await thpHandshake(device);
       } catch (error) {
         const isPinLocked = error.code === 'ThpDeviceLocked';
         const isTransportBusy = error.message === 'ThpTransportBusy';
@@ -43,27 +19,47 @@ const getThpChannel = async (device, withInteraction) => {
         thpState.resetState();
         if (isPinLocked && !withInteraction) return 'pin-locked';
         if (isPinLocked) {
-          device.emit(device_1.DEVICE.BUTTON, {
+          device.emit(DEVICE.BUTTON, {
             device,
             payload: {
               code: 'ButtonRequest_PinEntry'
             }
           });
         }
-        await (0, handshake_1.createThpChannel)(device);
-        await (0, handshake_1.thpHandshake)(device, isPinLocked);
+        await createThpChannel(device);
+        await thpHandshake(device, isPinLocked);
       }
     }
-    if (thpState.phase === 'pairing' && withInteraction) {
-      await (0, pairing_1.thpPairing)(device);
+    const startPairing = thpState.phase === 'pairing' && withInteraction;
+    if (startPairing) {
+      device.emit(DEVICE.THP_PAIRING_STATUS_CHANGED, {
+        status: 'started'
+      });
+      await thpPairing(device);
     }
     if (thpState.phase !== 'paired') {
+      device.emit(DEVICE.THP_PAIRING_STATUS_CHANGED, {
+        status: 'failed',
+        message: 'THP Locked'
+      });
       return 'thp-locked';
+    } else if (startPairing) {
+      device.emit(DEVICE.THP_PAIRING_STATUS_CHANGED, {
+        status: 'finished'
+      });
     }
   } catch (error) {
     thpState.resetState();
+    if (error.code === 'Device_ThpPairingTagInvalid') {} else if (error.code === 'Failure_ActionCancelled') {
+      device.emit(DEVICE.THP_PAIRING_STATUS_CHANGED, {
+        status: 'canceled'
+      });
+    } else {
+      device.emit(DEVICE.THP_PAIRING_STATUS_CHANGED, {
+        status: 'failed',
+        message: error.message
+      });
+    }
     throw error;
   }
-};
-exports.getThpChannel = getThpChannel;
-//# sourceMappingURL=index.js.map
+};

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

@@ -1,16 +1,16 @@
 import { thp as protocolThp } from '@trezor/protocol';
-import type { Device } from '../Device';
-export declare const getThpCredentials: (device: Device, autoconnect?: boolean) => Promise<{
-    autoconnect: boolean;
-    trezor_static_public_key: string;
-    credential: string;
+import type { IDevice } from "../../types/idevice.js";
+export declare const getThpCredentials: (device: IDevice, autoconnect?: boolean) => Promise<{
+  autoconnect: boolean;
+  host_static_key: string;
+  trezor_static_public_key: string;
+  credential: string;
 }>;
-export declare const thpPairingEnd: (device: Device) => Promise<{
-    type: "ThpEndResponse";
-    message: protocolThp.ThpEndResponse;
+export declare const thpPairingEnd: (device: IDevice) => Promise<{
+  type: "ThpEndResponse";
+  message: protocolThp.ThpEndResponse;
 }>;
-export declare const thpPairing: (device: Device) => Promise<{
-    type: "ThpEndResponse";
-    message: protocolThp.ThpEndResponse;
-} | undefined>;
-//# sourceMappingURL=pairing.d.ts.map
+export declare const thpPairing: (device: IDevice) => Promise<{
+  type: "ThpEndResponse";
+  message: protocolThp.ThpEndResponse;
+} | undefined>;

package/lib/device/thp/pairing.js

@@ -1,80 +1,74 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.thpPairing = exports.thpPairingEnd = exports.getThpCredentials = void 0;
-const crypto_1 = require("crypto");
-const protocol_1 = require("@trezor/protocol");
-const utils_1 = require("@trezor/utils");
-const constants_1 = require("../../constants");
-const DataManager_1 = require("../../data/DataManager");
-const events_1 = require("../../events");
-const thpCall_1 = require("./thpCall");
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex, concatBytes, randomBytes } from "@noble/hashes/utils.js";
+import { DEVICE } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { ThpPairingMethod, thp as protocolThp } from "@trezor/protocol";
+import { createDeferred, resolveAfter } from "@trezor/utils";
+import { abortThpWorkflow, thpCall } from "./thpCall.js";
+import * as settingsStore from "../../data/settingsStore.js";
+import { sanitizeString } from "../../utils/formatUtils.js";
+const sha256Hex = (...parts) => bytesToHex(sha256(concatBytes(...parts)));
 const processQrCodeTag = async (device, value) => {
   const thpState = device.getThpState();
   if (!thpState?.handshakeCredentials) {
-    throw constants_1.ERRORS.TypedError('Device_ThpStateMissing');
+    throw ERRORS.TypedError('Device_ThpStateMissing');
   }
-  const tagSha = (0, crypto_1.createHash)('sha256').update(thpState.handshakeCredentials.handshakeHash).update(Buffer.from(value, 'hex')).digest('hex');
-  const qrCodeSecret = await (0, thpCall_1.thpCall)(device, 'ThpQrCodeTag', {
+  const tagSha = sha256Hex(thpState.handshakeCredentials.handshakeHash, Buffer.from(value, 'hex'));
+  const qrCodeSecret = await thpCall(device, 'ThpQrCodeTag', {
     tag: tagSha
   });
-  protocol_1.thp.validateQrCodeTag(thpState.handshakeCredentials, value, qrCodeSecret.message.secret);
+  protocolThp.validateQrCodeTag(thpState.handshakeCredentials, value, qrCodeSecret.message.secret);
   return qrCodeSecret;
 };
 const processNfcTag = async (device, value) => {
   const thpState = device.getThpState();
   if (!thpState?.handshakeCredentials) {
-    throw constants_1.ERRORS.TypedError('Device_ThpStateMissing');
+    throw ERRORS.TypedError('Device_ThpStateMissing');
   }
   if (!thpState?.nfcSecret) {
     throw new Error('missing nfcSecret');
   }
-  const tagSha = (0, crypto_1.createHash)('sha256').update(Buffer.from([protocol_1.thp.ThpPairingMethod.NFC])).update(thpState.handshakeCredentials.handshakeHash).update(Buffer.from(value, 'hex')).digest('hex');
-  const nfcTagTrezor = await (0, thpCall_1.thpCall)(device, 'ThpNfcTagHost', {
+  const tagSha = sha256Hex(Buffer.from([protocolThp.ThpPairingMethod.NFC]), thpState.handshakeCredentials.handshakeHash, Buffer.from(value, 'hex'));
+  const nfcTagTrezor = await thpCall(device, 'ThpNfcTagHost', {
     tag: tagSha
   });
-  protocol_1.thp.validateNfcTag(thpState.handshakeCredentials, nfcTagTrezor.message.tag, thpState.nfcSecret);
+  protocolThp.validateNfcTag(thpState.handshakeCredentials, nfcTagTrezor.message.tag, thpState.nfcSecret);
   return nfcTagTrezor;
 };
 const processCodeEntry = async (device, value) => {
-  if (value.length !== 6) {
-    throw constants_1.ERRORS.TypedError('Device_ThpPairingTagInvalid');
-  }
   const codeValue = Buffer.from(value, 'ascii');
   const thpState = device.getThpState();
   if (!thpState?.handshakeCredentials) {
-    throw constants_1.ERRORS.TypedError('Device_ThpStateMissing');
+    throw ERRORS.TypedError('Device_ThpStateMissing');
   }
-  const hostKeys = protocol_1.thp.getCpaceHostKeys(codeValue, thpState.handshakeCredentials.handshakeHash);
-  const tag = protocol_1.thp.getSharedSecret(thpState.handshakeCredentials.trezorCpacePublicKey, hostKeys.privateKey).toString('hex');
-  const codeEntrySecret = await (0, thpCall_1.thpCall)(device, 'ThpCodeEntryCpaceHostTag', {
+  const hostKeys = protocolThp.getCpaceHostKeys(codeValue, thpState.handshakeCredentials.handshakeHash);
+  const tag = protocolThp.getSharedSecret(thpState.handshakeCredentials.trezorCpacePublicKey, hostKeys.privateKey).toString('hex');
+  const codeEntrySecret = await thpCall(device, 'ThpCodeEntryCpaceHostTag', {
     tag,
     cpace_host_public_key: hostKeys.publicKey.toString('hex')
   });
-  protocol_1.thp.validateCodeEntryTag(thpState.handshakeCredentials, value, codeEntrySecret.message.secret);
+  protocolThp.validateCodeEntryTag(thpState.handshakeCredentials, value, codeEntrySecret.message.secret);
   return codeEntrySecret;
 };
 const processThpPairingResponse = (device, payload) => {
   if ('selectedMethod' in payload) {
-    const selectedMethod = protocol_1.thp.getThpPairingMethod(payload.selectedMethod);
+    const selectedMethod = protocolThp.getThpPairingMethod(payload.selectedMethod);
     device.getThpState()?.setPairingMethod(selectedMethod);
-    return (0, thpCall_1.thpCall)(device, 'ThpSelectMethod', {
+    return thpCall(device, 'ThpSelectMethod', {
       selected_pairing_method: selectedMethod
     });
   }
   const selectedMethod = device.getThpState()?.pairingMethod;
-  if (selectedMethod === protocol_1.ThpPairingMethod.QrCode) {
+  if (selectedMethod === ThpPairingMethod.QrCode) {
     return processQrCodeTag(device, payload.tag);
   }
-  if (selectedMethod === protocol_1.ThpPairingMethod.NFC) {
+  if (selectedMethod === ThpPairingMethod.NFC) {
     return processNfcTag(device, payload.tag);
   }
-  if (selectedMethod === protocol_1.ThpPairingMethod.CodeEntry) {
+  if (selectedMethod === ThpPairingMethod.CodeEntry) {
     return processCodeEntry(device, payload.tag);
   }
-  throw constants_1.ERRORS.TypedError('Device_ThpPairingMethodsException');
+  throw ERRORS.TypedError('Device_ThpPairingMethodsException');
 };
 const waitForPairingCancel = device => {
   const readAbort = new AbortController();
@@ -90,26 +84,30 @@ const waitForPairingCancel = device => {
 const waitForPairingTag = async device => {
   const thpState = device.getThpState();
   if (!thpState?.handshakeCredentials) {
-    throw constants_1.ERRORS.TypedError('Device_ThpStateMissing');
+    throw ERRORS.TypedError('Device_ThpStateMissing');
   }
   if (thpState.pairingMethod === undefined) {
-    throw constants_1.ERRORS.TypedError('Device_ThpPairingMethodsException');
+    throw ERRORS.TypedError('Device_ThpPairingMethodsException');
   }
-  const dfd = (0, utils_1.createDeferred)();
+  const dfd = createDeferred();
   const {
     readAbort,
     readCancel
   } = waitForPairingCancel(device);
   const cancelResult = readCancel.then(readResult => {
     if (readResult.success) {
-      let error;
-      if (readResult.payload.type === 'Failure' && readResult.payload.message.message) {
-        error = readResult.payload.message.message;
+      let code, message;
+      const {
+        payload
+      } = readResult;
+      if (payload.type === 'Failure') {
+        code = payload.message.code;
+        message = payload.message.message;
       } else {
-        error = `Pairing tag cancelled (${readResult.payload.type})`;
+        message = `Unexpected message type: ${readResult.payload.type}`;
       }
       dfd.resolve({
-        error
+        error: ERRORS.TypedError(code || 'ThpUnknownError', message)
       });
     }
   }).catch(() => {});
@@ -124,15 +122,15 @@ const waitForPairingTag = async device => {
     selectedMethod: thpState.pairingMethod,
     nfcData: thpState.nfcData?.toString('hex')
   };
-  device.prompt(events_1.DEVICE.THP_PAIRING, {
+  device.prompt(DEVICE.THP_PAIRING, {
     payload
   }).then(response => {
     if (response.success) {
       dfd.resolve(response.payload);
     } else {
-      (0, thpCall_1.abortThpWorkflow)(device).then(() => {
+      abortThpWorkflow(device).then(() => {
         dfd.resolve({
-          error: response.error.message
+          error: ERRORS.TypedError('ThpUnknownError', response.error.message)
         });
       });
     }
@@ -142,56 +140,66 @@ const waitForPairingTag = async device => {
   await readCancel;
   thpState.setPairingTagPromise(undefined);
   if ('error' in pairingResponse) {
-    throw new Error(pairingResponse.error);
+    throw pairingResponse.error;
   }
-  await new Promise(resolve => setTimeout(resolve, 500));
+  await resolveAfter(500);
   return processThpPairingResponse(device, pairingResponse).catch(e => {
-    if (e.code === 'Failure_FirmwareError') {
-      throw constants_1.ERRORS.TypedError('Device_ThpPairingTagInvalid', e.message);
+    if (e.code === 'Failure_FirmwareError' || e.code === 'Failure_DataError') {
+      if ('tag' in pairingResponse) {
+        device.emit(DEVICE.THP_PAIRING_STATUS_CHANGED, {
+          status: 'invalid-tag',
+          tag: pairingResponse.tag
+        });
+      }
+      throw ERRORS.TypedError('Device_ThpPairingTagInvalid', e.message);
     }
-    throw constants_1.ERRORS.TypedError(e.code, e.message);
+    throw ERRORS.TypedError(e.code, e.message);
   });
 };
-const getThpCredentials = async (device, autoconnect = false) => {
+export const getThpCredentials = async (device, autoconnect = false) => {
   const thpState = device.getThpState();
   if (!thpState?.handshakeCredentials) {
-    throw constants_1.ERRORS.TypedError('Device_ThpStateMissing');
+    throw ERRORS.TypedError('Device_ThpStateMissing');
   }
-  const credentials = await (0, thpCall_1.thpCall)(device, 'ThpCredentialRequest', {
+  const credentials = await thpCall(device, 'ThpCredentialRequest', {
     autoconnect,
     host_static_public_key: thpState.handshakeCredentials.hostStaticPublicKey.toString('hex'),
     credential: thpState.pairingCredentials[0]?.credential
   });
+  const host_static_key = thpState.handshakeCredentials.staticKey.toString('hex');
   return {
     ...credentials.message,
-    autoconnect
+    autoconnect,
+    host_static_key
   };
 };
-exports.getThpCredentials = getThpCredentials;
-const thpPairingEnd = device => {
+export const thpPairingEnd = async device => {
+  const result = await thpCall(device, 'ThpEndRequest', {});
   device.getThpState()?.setPhase('paired');
-  return (0, thpCall_1.thpCall)(device, 'ThpEndRequest', {});
+  return result;
 };
-exports.thpPairingEnd = thpPairingEnd;
-const thpPairing = async device => {
+export const thpPairing = async device => {
   const thpState = device.getThpState();
   if (!thpState?.handshakeCredentials) {
-    throw constants_1.ERRORS.TypedError('Device_ThpStateMissing');
+    throw ERRORS.TypedError('Device_ThpStateMissing');
   }
-  if (thpState.isPaired && thpState.pairingMethod !== protocol_1.thp.ThpPairingMethod.SkipPairing) {
+  if (thpState.isPaired && thpState.pairingMethod !== protocolThp.ThpPairingMethod.SkipPairing) {
     if (!thpState.isAutoconnectPaired) {
-      await (0, exports.getThpCredentials)(device, false);
+      await getThpCredentials(device, false);
     }
-    return (0, exports.thpPairingEnd)(device);
+    return thpPairingEnd(device);
   }
-  const [selected_pairing_method] = thpState.handshakeCredentials.pairingMethods;
+  const {
+    pairingMethods
+  } = thpState.handshakeCredentials;
+  const selected_pairing_method = pairingMethods[0];
   thpState.setPairingMethod(selected_pairing_method);
-  const settings = DataManager_1.DataManager.getSettings('thp');
-  await (0, thpCall_1.thpCall)(device, 'ThpPairingRequest', {
-    host_name: settings?.hostName || 'Unknown hostName',
-    app_name: settings?.appName || 'Unknown appName'
+  const settings = settingsStore.get('thp');
+  await thpCall(device, 'ThpPairingRequest', {
+    host_name: sanitizeString(settings?.hostName) || 'Unknown hostName',
+    app_name: sanitizeString(settings?.appName) || 'Unknown appName'
   });
-  const selectMethod = await (0, thpCall_1.thpCall)(device, 'ThpSelectMethod', {
+  const selectMethod = await thpCall(device, 'ThpSelectMethod', {
     selected_pairing_method
   });
   if (selectMethod.type === 'ThpEndResponse') {
@@ -200,13 +208,13 @@ const thpPairing = async device => {
     return;
   }
   if (selectMethod.type === 'ThpCodeEntryCommitment') {
-    const codeEntryChallenge = (0, crypto_1.randomBytes)(32);
+    const codeEntryChallenge = Buffer.from(randomBytes(32));
     const handshakeCommitment = Buffer.from(selectMethod.message.commitment, 'hex');
     thpState.updateHandshakeCredentials({
       handshakeCommitment,
       codeEntryChallenge
     });
-    const codeEntryCpace = await (0, thpCall_1.thpCall)(device, 'ThpCodeEntryChallenge', {
+    const codeEntryCpace = await thpCall(device, 'ThpCodeEntryChallenge', {
       challenge: codeEntryChallenge.toString('hex')
     });
     thpState.updateHandshakeCredentials({
@@ -215,24 +223,20 @@ const thpPairing = async device => {
     await waitForPairingTag(device);
   }
   if (selectMethod.type === 'ThpPairingPreparationsFinished') {
-    if (thpState.pairingMethod === protocol_1.thp.ThpPairingMethod.NFC) {
-      thpState.setNfcSecret((0, crypto_1.randomBytes)(16));
+    if (thpState.pairingMethod === protocolThp.ThpPairingMethod.NFC) {
+      thpState.setNfcSecret(Buffer.from(randomBytes(16)));
     }
     await waitForPairingTag(device);
   }
-  const credentials = await (0, exports.getThpCredentials)(device, false);
-  device.emit(events_1.DEVICE.THP_CREDENTIALS_CHANGED, {
-    credentials,
-    staticKey: thpState.handshakeCredentials.staticKey.toString('hex')
+  const credentials = await getThpCredentials(device, false);
+  device.emit(DEVICE.THP_CREDENTIALS_CHANGED, {
+    credentials
   });
-  const settings1 = DataManager_1.DataManager.getSettings('thp');
+  const settings1 = settingsStore.get('thp');
   if (settings1) {
     settings1.knownCredentials?.push(credentials);
-    settings1.staticKey = thpState.handshakeCredentials.staticKey.toString('hex');
   }
   thpState.setPairingCredentials([credentials]);
   thpState.setIsPaired(true);
-  await (0, exports.thpPairingEnd)(device);
-};
-exports.thpPairing = thpPairing;
-//# sourceMappingURL=pairing.js.map
+  await thpPairingEnd(device);
+};

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

@@ -1,3 +1,2 @@
-import type { Device } from '../Device';
-export declare const createThpSession: (device: Device, deriveCardano: boolean) => Promise<number>;
-//# sourceMappingURL=session.d.ts.map
+import type { IDevice } from "../../types/idevice.js";
+export declare const createThpSession: (device: IDevice, deriveCardano: boolean) => Promise<number>;

package/lib/device/thp/session.js

@@ -1,11 +1,5 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createThpSession = void 0;
-const thpCall_1 = require("./thpCall");
-const createThpSession = async (device, deriveCardano) => {
+import { thpCall } from "./thpCall.js";
+export const createThpSession = async (device, deriveCardano) => {
   let passphrase;
   if (device.features.passphrase_protection === false) {
     passphrase = {
@@ -25,11 +19,9 @@ const createThpSession = async (device, deriveCardano) => {
       };
     });
   }
-  await (0, thpCall_1.thpCall)(device, 'ThpCreateNewSession', {
+  await thpCall(device, 'ThpCreateNewSession', {
     ...passphrase,
     derive_cardano: deriveCardano
   });
   return 0;
-};
-exports.createThpSession = createThpSession;
-//# sourceMappingURL=session.js.map
+};

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

@@ -1,41 +1,31 @@
-import { thp as protocolThp } from '@trezor/protocol';
-import type { Device } from '../Device';
+import type { thp as protocolThp } from '@trezor/protocol';
+import type { IDevice } from "../../types/idevice.js";
 type ThpTypedCall = {
-    ThpCreateChannelRequest: 'ThpCreateChannelResponse';
-    ThpHandshakeInitRequest: 'ThpHandshakeInitResponse';
-    ThpHandshakeCompletionRequest: 'ThpHandshakeCompletionResponse';
-    ThpPairingRequest: 'ThpPairingRequestApproved';
-    ThpSelectMethod: [
-        'ThpCodeEntryCommitment',
-        'ThpEndResponse',
-        'ThpPairingRequestApproved',
-        'ThpPairingPreparationsFinished'
-    ];
-    ThpCodeEntryChallenge: ['ThpCodeEntryCpaceTrezor'];
-    ThpCodeEntryCpaceHostTag: 'ThpCodeEntrySecret';
-    ThpQrCodeTag: 'ThpQrCodeSecret';
-    ThpNfcTagHost: 'ThpNfcTagTrezor';
-    ThpCredentialRequest: 'ThpCredentialResponse';
-    ThpEndRequest: 'ThpEndResponse';
-    ThpCreateNewSession: 'Success';
+  ThpCreateChannelRequest: 'ThpCreateChannelResponse';
+  ThpHandshakeInitRequest: 'ThpHandshakeInitResponse';
+  ThpHandshakeCompletionRequest: 'ThpHandshakeCompletionResponse';
+  ThpPairingRequest: 'ThpPairingRequestApproved';
+  ThpSelectMethod: ['ThpCodeEntryCommitment', 'ThpEndResponse', 'ThpPairingRequestApproved', 'ThpPairingPreparationsFinished'];
+  ThpCodeEntryChallenge: ['ThpCodeEntryCpaceTrezor'];
+  ThpCodeEntryCpaceHostTag: 'ThpCodeEntrySecret';
+  ThpQrCodeTag: 'ThpQrCodeSecret';
+  ThpNfcTagHost: 'ThpNfcTagTrezor';
+  ThpCredentialRequest: 'ThpCredentialResponse';
+  ThpEndRequest: 'ThpEndResponse';
+  ThpCreateNewSession: 'Success';
 };
 type ThpMessage = protocolThp.ThpMessageType & {
-    Success: {};
+  Success: Record<never, never>;
 };
 type TypedPayloadItem<K> = K extends keyof ThpMessage ? {
-    type: K;
-    message: ThpMessage[K];
+  type: K;
+  message: ThpMessage[K];
 } : never;
-type ExtractFromArray<A extends any[]> = {
-    [K in keyof A]: TypedPayloadItem<A[K]>;
-}[number];
+type ExtractFromArray<A extends any[]> = { [K in keyof A]: TypedPayloadItem<A[K]> }[number];
 type MessageKey = keyof ThpTypedCall;
 type TypedPayload<T extends MessageKey> = ThpTypedCall[T] extends any[] ? ExtractFromArray<ThpTypedCall[T]> : TypedPayloadItem<ThpTypedCall[T]>;
-type ThpCallResponse = {
-    [K in keyof ThpTypedCall]: TypedPayload<K>;
-};
+type ThpCallResponse = { [K in keyof ThpTypedCall]: TypedPayload<K> };
 type ThpMessagePayload<T extends MessageKey = MessageKey> = ThpMessage[T];
-export declare const thpCall: <T extends MessageKey>(device: Device, name: T, data: ThpMessagePayload<T>) => Promise<ThpCallResponse[T]>;
-export declare const abortThpWorkflow: (device: Device) => Promise<void>;
-export {};
-//# sourceMappingURL=thpCall.d.ts.map
+export declare const thpCall: <T extends MessageKey>(device: IDevice, name: T, data: ThpMessagePayload<T>) => Promise<ThpCallResponse[T]>;
+export declare const abortThpWorkflow: (device: IDevice) => Promise<void>;
+export {};

package/lib/device/thp/thpCall.js

@@ -1,15 +1,9 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.abortThpWorkflow = exports.thpCall = void 0;
-const errors_1 = require("../../constants/errors");
-const events_1 = require("../../events");
-const thpCall = async (device, name, data) => {
+import { DEVICE } from "@trezor/connect-common";
+import { TypedError } from "@trezor/connect-common/lib/constants/errors.js";
+export const thpCall = async (device, name, data) => {
   const thpState = device.getThpState();
   if (!thpState) {
-    throw (0, errors_1.TypedError)('Device_ThpStateMissing');
+    throw TypedError('Device_ThpStateMissing');
   }
   const result = await device.getCurrentSession().call(name, data);
   if (!result.success) {
@@ -19,33 +13,32 @@ const thpCall = async (device, name, data) => {
   if (result.payload.type === 'ButtonRequest') {
     thpState.setCancelablePromise(true);
     if (result.payload.message.code === 'ButtonRequest_PassphraseEntry') {
-      device.emit(events_1.DEVICE.PASSPHRASE_ON_DEVICE);
+      device.emit(DEVICE.PASSPHRASE_ON_DEVICE);
     } else {
-      device.emit(events_1.DEVICE.BUTTON, {
+      device.emit(DEVICE.BUTTON, {
         device,
         payload: result.payload.message
       });
     }
-    return (0, exports.thpCall)(device, 'ButtonAck', {});
+    return thpCall(device, 'ButtonAck', {});
   }
   if (result.payload.type === 'Failure') {
     const {
       code,
       message
     } = result.payload.message;
-    throw (0, errors_1.TypedError)(code || 'Failure_UnknownCode', message);
+    throw TypedError(code || 'Failure_UnknownCode', message);
   }
   if (result.payload.type === 'ThpError') {
     const {
       code,
       message
     } = result.payload.message;
-    throw (0, errors_1.TypedError)(code, message);
+    throw TypedError(code, message);
   }
   return result.payload;
 };
-exports.thpCall = thpCall;
-const abortThpWorkflow = async device => {
+export const abortThpWorkflow = async device => {
   const thpState = device.getThpState();
   if (!thpState || !device.currentRun) {
     return Promise.resolve();
@@ -54,11 +47,12 @@ const abortThpWorkflow = async device => {
     await thpState.pairingTagPromise.abort();
     await device.getCurrentSession().cancelCall();
     thpState.resetState();
+    device.emit(DEVICE.THP_PAIRING_STATUS_CHANGED, {
+      status: 'canceled'
+    });
   } else if (thpState.cancelablePromise) {
     thpState.sync('send', 'Cancel');
     await device.getCurrentSession().send('Cancel', {});
     await device.currentRun;
   }
-};
-exports.abortThpWorkflow = abortThpWorkflow;
-//# sourceMappingURL=thpCall.js.map
+};

package/lib/device/validateMessageSize.d.ts

@@ -0,0 +1,2 @@
+import type { Device } from "./Device.js";
+export declare const validateModelOneMessageSize: (device: Device, messageHex: string) => void;

package/lib/device/validateMessageSize.js

@@ -0,0 +1,9 @@
+import { TypedError } from "@trezor/connect-common/lib/constants/errors.js";
+export const validateModelOneMessageSize = (device, messageHex) => {
+  if (device.features?.major_version === 1) {
+    const byteSize = messageHex.length / 2;
+    if (byteSize > 1024) {
+      throw TypedError('Method_DataOverflowModelOne');
+    }
+  }
+};

package/lib/device/workflow/changeLanguage.d.ts

@@ -0,0 +1,18 @@
+import type { IDevice } from "../../types/idevice.js";
+type Context = {
+  device: IDevice;
+} & ({
+  language?: undefined;
+  binary: ArrayBuffer;
+} | {
+  language: string;
+  binary?: undefined;
+});
+export declare const changeLanguage: ({
+  device,
+  language,
+  binary
+}: Context) => Promise<{
+  message: string;
+}>;
+export {};