@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/lib/device/thp/pairing.js

@@ -1,238 +0,0 @@
-"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");
-const processQrCodeTag = async (device, value) => {
-  const thpState = device.getThpState();
-  if (!thpState?.handshakeCredentials) {
-    throw constants_1.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', {
-    tag: tagSha
-  });
-  protocol_1.thp.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');
-  }
-  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', {
-    tag: tagSha
-  });
-  protocol_1.thp.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');
-  }
-  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', {
-    tag,
-    cpace_host_public_key: hostKeys.publicKey.toString('hex')
-  });
-  protocol_1.thp.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);
-    device.getThpState()?.setPairingMethod(selectedMethod);
-    return (0, thpCall_1.thpCall)(device, 'ThpSelectMethod', {
-      selected_pairing_method: selectedMethod
-    });
-  }
-  const selectedMethod = device.getThpState()?.pairingMethod;
-  if (selectedMethod === protocol_1.ThpPairingMethod.QrCode) {
-    return processQrCodeTag(device, payload.tag);
-  }
-  if (selectedMethod === protocol_1.ThpPairingMethod.NFC) {
-    return processNfcTag(device, payload.tag);
-  }
-  if (selectedMethod === protocol_1.ThpPairingMethod.CodeEntry) {
-    return processCodeEntry(device, payload.tag);
-  }
-  throw constants_1.ERRORS.TypedError('Device_ThpPairingMethodsException');
-};
-const waitForPairingCancel = device => {
-  const readAbort = new AbortController();
-  device.getThpState()?.setExpectedResponses([0x04]);
-  const readCancel = device.getCurrentSession().receive({
-    signal: readAbort.signal
-  });
-  return {
-    readAbort,
-    readCancel
-  };
-};
-const waitForPairingTag = async device => {
-  const thpState = device.getThpState();
-  if (!thpState?.handshakeCredentials) {
-    throw constants_1.ERRORS.TypedError('Device_ThpStateMissing');
-  }
-  if (thpState.pairingMethod === undefined) {
-    throw constants_1.ERRORS.TypedError('Device_ThpPairingMethodsException');
-  }
-  const dfd = (0, utils_1.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;
-      } else {
-        error = `Pairing tag cancelled (${readResult.payload.type})`;
-      }
-      dfd.resolve({
-        error
-      });
-    }
-  }).catch(() => {});
-  thpState.setPairingTagPromise({
-    abort: async () => {
-      readAbort.abort();
-      await cancelResult;
-    }
-  });
-  const payload = {
-    availableMethods: thpState.handshakeCredentials.pairingMethods,
-    selectedMethod: thpState.pairingMethod,
-    nfcData: thpState.nfcData?.toString('hex')
-  };
-  device.prompt(events_1.DEVICE.THP_PAIRING, {
-    payload
-  }).then(response => {
-    if (response.success) {
-      dfd.resolve(response.payload);
-    } else {
-      (0, thpCall_1.abortThpWorkflow)(device).then(() => {
-        dfd.resolve({
-          error: response.error.message
-        });
-      });
-    }
-  });
-  const pairingResponse = await dfd.promise;
-  readAbort.abort();
-  await readCancel;
-  thpState.setPairingTagPromise(undefined);
-  if ('error' in pairingResponse) {
-    throw new Error(pairingResponse.error);
-  }
-  await new Promise(resolve => setTimeout(resolve, 500));
-  return processThpPairingResponse(device, pairingResponse).catch(e => {
-    if (e.code === 'Failure_FirmwareError') {
-      throw constants_1.ERRORS.TypedError('Device_ThpPairingTagInvalid', e.message);
-    }
-    throw constants_1.ERRORS.TypedError(e.code, e.message);
-  });
-};
-const getThpCredentials = async (device, autoconnect = false) => {
-  const thpState = device.getThpState();
-  if (!thpState?.handshakeCredentials) {
-    throw constants_1.ERRORS.TypedError('Device_ThpStateMissing');
-  }
-  const credentials = await (0, thpCall_1.thpCall)(device, 'ThpCredentialRequest', {
-    autoconnect,
-    host_static_public_key: thpState.handshakeCredentials.hostStaticPublicKey.toString('hex'),
-    credential: thpState.pairingCredentials[0]?.credential
-  });
-  return {
-    ...credentials.message,
-    autoconnect
-  };
-};
-exports.getThpCredentials = getThpCredentials;
-const thpPairingEnd = device => {
-  device.getThpState()?.setPhase('paired');
-  return (0, thpCall_1.thpCall)(device, 'ThpEndRequest', {});
-};
-exports.thpPairingEnd = thpPairingEnd;
-const thpPairing = async device => {
-  const thpState = device.getThpState();
-  if (!thpState?.handshakeCredentials) {
-    throw constants_1.ERRORS.TypedError('Device_ThpStateMissing');
-  }
-  if (thpState.isPaired && thpState.pairingMethod !== protocol_1.thp.ThpPairingMethod.SkipPairing) {
-    if (!thpState.isAutoconnectPaired) {
-      await (0, exports.getThpCredentials)(device, false);
-    }
-    return (0, exports.thpPairingEnd)(device);
-  }
-  const [selected_pairing_method] = thpState.handshakeCredentials.pairingMethods;
-  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 selectMethod = await (0, thpCall_1.thpCall)(device, 'ThpSelectMethod', {
-    selected_pairing_method
-  });
-  if (selectMethod.type === 'ThpEndResponse') {
-    thpState.setIsPaired(true);
-    device.getThpState()?.setPhase('paired');
-    return;
-  }
-  if (selectMethod.type === 'ThpCodeEntryCommitment') {
-    const codeEntryChallenge = (0, crypto_1.randomBytes)(32);
-    const handshakeCommitment = Buffer.from(selectMethod.message.commitment, 'hex');
-    thpState.updateHandshakeCredentials({
-      handshakeCommitment,
-      codeEntryChallenge
-    });
-    const codeEntryCpace = await (0, thpCall_1.thpCall)(device, 'ThpCodeEntryChallenge', {
-      challenge: codeEntryChallenge.toString('hex')
-    });
-    thpState.updateHandshakeCredentials({
-      trezorCpacePublicKey: Buffer.from(codeEntryCpace.message.cpace_trezor_public_key, 'hex')
-    });
-    await waitForPairingTag(device);
-  }
-  if (selectMethod.type === 'ThpPairingPreparationsFinished') {
-    if (thpState.pairingMethod === protocol_1.thp.ThpPairingMethod.NFC) {
-      thpState.setNfcSecret((0, crypto_1.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 settings1 = DataManager_1.DataManager.getSettings('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

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

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

package/lib/device/thp/session.js

@@ -1,35 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createThpSession = void 0;
-const thpCall_1 = require("./thpCall");
-const createThpSession = async (device, deriveCardano) => {
-  let passphrase;
-  if (device.features.passphrase_protection === false) {
-    passphrase = {
-      passphrase: ''
-    };
-  } else {
-    passphrase = await device.prompt('passphrase', {}).then(promptRes => {
-      if (!promptRes.success) {
-        return {
-          passphrase: ''
-        };
-      }
-      return promptRes.payload.passphraseOnDevice ? {
-        on_device: true
-      } : {
-        passphrase: promptRes.payload.value.normalize('NFKD')
-      };
-    });
-  }
-  await (0, thpCall_1.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 +0,0 @@
-import { thp as protocolThp } from '@trezor/protocol';
-import type { Device } from '../Device';
-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';
-};
-type ThpMessage = protocolThp.ThpMessageType & {
-    Success: {};
-};
-type TypedPayloadItem<K> = K extends keyof ThpMessage ? {
-    type: K;
-    message: ThpMessage[K];
-} : never;
-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 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

package/lib/device/thp/thpCall.js

@@ -1,64 +0,0 @@
-"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) => {
-  const thpState = device.getThpState();
-  if (!thpState) {
-    throw (0, errors_1.TypedError)('Device_ThpStateMissing');
-  }
-  const result = await device.getCurrentSession().call(name, data);
-  if (!result.success) {
-    throw result.error;
-  }
-  thpState.setCancelablePromise(false);
-  if (result.payload.type === 'ButtonRequest') {
-    thpState.setCancelablePromise(true);
-    if (result.payload.message.code === 'ButtonRequest_PassphraseEntry') {
-      device.emit(events_1.DEVICE.PASSPHRASE_ON_DEVICE);
-    } else {
-      device.emit(events_1.DEVICE.BUTTON, {
-        device,
-        payload: result.payload.message
-      });
-    }
-    return (0, exports.thpCall)(device, 'ButtonAck', {});
-  }
-  if (result.payload.type === 'Failure') {
-    const {
-      code,
-      message
-    } = result.payload.message;
-    throw (0, errors_1.TypedError)(code || 'Failure_UnknownCode', message);
-  }
-  if (result.payload.type === 'ThpError') {
-    const {
-      code,
-      message
-    } = result.payload.message;
-    throw (0, errors_1.TypedError)(code, message);
-  }
-  return result.payload;
-};
-exports.thpCall = thpCall;
-const abortThpWorkflow = async device => {
-  const thpState = device.getThpState();
-  if (!thpState || !device.currentRun) {
-    return Promise.resolve();
-  }
-  if (thpState.pairingTagPromise) {
-    await thpState.pairingTagPromise.abort();
-    await device.getCurrentSession().cancelCall();
-    thpState.resetState();
-  } 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/workflow/checkFirmwareHash.d.ts

@@ -1,10 +0,0 @@
-import { FirmwareHashCheckResult } from '../../types';
-import { Log } from '../../utils/debug';
-import type { Device } from '../Device';
-type Context = {
-    device: Device;
-    logger: Log;
-};
-export declare const checkFirmwareHash: ({ device, logger, }: Context) => Promise<FirmwareHashCheckResult | null>;
-export {};
-//# sourceMappingURL=checkFirmwareHash.d.ts.map

package/lib/device/workflow/checkFirmwareHash.js

@@ -1,94 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.checkFirmwareHash = void 0;
-const crypto_1 = require("crypto");
-const utils_1 = require("@trezor/utils");
-const firmware_1 = require("../../api/firmware");
-const DataManager_1 = require("../../data/DataManager");
-const firmwareInfo_1 = require("../../data/firmwareInfo");
-const firmwareUtils_1 = require("../../utils/firmwareUtils");
-const createFailResult = (error, errorPayload) => ({
-  success: false,
-  error,
-  errorPayload
-});
-const checkFirmwareHash = async ({
-  device,
-  logger
-}) => {
-  const enabled = DataManager_1.DataManager.getSettings('enableFirmwareHashCheck');
-  if (!enabled) return createFailResult('check-skipped');
-  const firmwareVersion = device.getVersion();
-  if (firmwareVersion === undefined || !device.features || device.features.bootloader_mode) {
-    return null;
-  }
-  const firmwareType = (0, firmwareUtils_1.getFirmwareType)(device.features);
-  const release = await (0, firmwareInfo_1.getReleaseByVersion)(device.features, firmwareVersion, firmwareType);
-  if (!release) return createFailResult('unknown-release');
-  const firmwareLocation = (0, firmwareInfo_1.getFirmwareLocation)({
-    firmwareVersion,
-    remotePath: release.url,
-    deviceModel: device.features.internal_model,
-    firmwareType: (0, firmwareUtils_1.getFirmwareType)(device.features)
-  });
-  const {
-    baseUrl,
-    path
-  } = firmwareLocation;
-  const timeoutThresholdsPerModel = DataManager_1.DataManager.getSettings('firmwareHashCheckTimeouts');
-  if (firmwareVersion === undefined || !device.features || device.features.bootloader_mode) {
-    return null;
-  }
-  const checkSupported = !device.unavailableCapabilities.getFirmwareHash;
-  if (!checkSupported) return createFailResult('check-unsupported');
-  const firmwareBinary = await (0, firmware_1.getBinaryOptional)({
-    baseUrl,
-    path,
-    release
-  });
-  if (firmwareBinary === null) {
-    return createFailResult('check-unsupported');
-  }
-  if (firmwareBinary.binary.byteLength < 200) {
-    logger.warn(`Firmware binary for hash check suspiciously small (< 200 b)`);
-    return createFailResult('check-unsupported');
-  }
-  const strippedBinary = (0, firmware_1.stripFwHeaders)(firmwareBinary.binary);
-  const {
-    hash: expectedHash,
-    challenge
-  } = (0, firmware_1.calculateFirmwareHash)({
-    internal_model: device.features.internal_model,
-    firmwareVersion,
-    fw: strippedBinary,
-    key: (0, crypto_1.randomBytes)(32)
-  });
-  try {
-    const ts = performance.now();
-    const deviceResponse = await device.getCurrentSession().typedCall('GetFirmwareHash', 'FirmwareHash', {
-      challenge
-    });
-    if (!deviceResponse?.message?.hash) {
-      return createFailResult('other-error', 'Device response is missing hash');
-    }
-    if (deviceResponse.message.hash !== expectedHash) {
-      return createFailResult('hash-mismatch');
-    }
-    const duration = performance.now() - ts;
-    logger.debug('GetFirmwareHash time', duration);
-    const timeoutThreshold = timeoutThresholdsPerModel?.[device.features.internal_model];
-    if (timeoutThreshold !== undefined && duration > timeoutThreshold) {
-      return createFailResult('takes-too-long');
-    }
-    return {
-      success: true
-    };
-  } catch (errorPayload) {
-    return createFailResult('other-error', (0, utils_1.serializeError)(errorPayload));
-  }
-};
-exports.checkFirmwareHash = checkFirmwareHash;
-//# sourceMappingURL=checkFirmwareHash.js.map

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

@@ -1,9 +0,0 @@
-import { Log } from '../../utils/debug';
-import type { Device } from '../Device';
-type Context = {
-    device: Device;
-    logger: Log;
-};
-export declare const checkFirmwareHashWithRetries: (context: Context) => Promise<void>;
-export {};
-//# sourceMappingURL=checkFirmwareHashWithRetries.d.ts.map

package/lib/device/workflow/checkFirmwareHashWithRetries.js

@@ -1,44 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.checkFirmwareHashWithRetries = void 0;
-const utils_1 = require("@trezor/utils");
-const constants_1 = require("../../constants");
-const checkFirmwareHash_1 = require("./checkFirmwareHash");
-const PROBE_CHECK_TIME_RETRIES = 4;
-const probeCheckTime = async context => {
-  for (let i = 0; i < PROBE_CHECK_TIME_RETRIES; i++) {
-    const result = await (0, checkFirmwareHash_1.checkFirmwareHash)(context);
-    if (result !== null && (result.success || result.error !== 'takes-too-long')) {
-      context.device.setAuthenticityChecks(result);
-      return;
-    }
-  }
-};
-const checkFirmwareHashWithRetries = async context => {
-  const lastResult = context.device.getAuthenticityChecks().firmwareHash;
-  const notDoneYet = lastResult === null;
-  const attemptsDone = lastResult?.attemptCount ?? 0;
-  if (attemptsDone >= constants_1.FIRMWARE.HASH_CHECK_MAX_ATTEMPTS) return;
-  const wasError = lastResult !== null && !lastResult.success;
-  const wasErrorRetriable = wasError && (0, utils_1.isArrayMember)(lastResult.error, constants_1.FIRMWARE.HASH_CHECK_RETRIABLE_ERRORS);
-  const lastErrorPayload = wasError ? lastResult?.errorPayload : null;
-  if (notDoneYet || wasErrorRetriable) {
-    const result = await (0, checkFirmwareHash_1.checkFirmwareHash)(context);
-    context.device.setAuthenticityChecks(result);
-    if (result === null) return;
-    result.attemptCount = attemptsDone + 1;
-    if (!result.success && result.error === 'takes-too-long') {
-      await probeCheckTime(context);
-    }
-    if (result.success && lastErrorPayload) {
-      result.warningPayload = {
-        lastErrorPayload
-      };
-    }
-  }
-};
-exports.checkFirmwareHashWithRetries = checkFirmwareHashWithRetries;
-//# sourceMappingURL=checkFirmwareHashWithRetries.js.map

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

@@ -1,10 +0,0 @@
-import { WorkflowContext } from '../../types/workflow';
-import { Log } from '../../utils/debug';
-type Context = {
-    device: WorkflowContext['device'];
-    signal: AbortSignal;
-    logger?: Log;
-};
-export declare const handshakeCancel: ({ device, logger, signal }: Context) => Promise<void>;
-export {};
-//# sourceMappingURL=handshake.d.ts.map

package/lib/device/workflow/handshake.js

@@ -1,63 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.handshakeCancel = void 0;
-const protocol_1 = require("@trezor/protocol");
-const transport_1 = require("@trezor/transport");
-const utils_1 = require("@trezor/utils");
-const errors_1 = require("../../constants/errors");
-const CANCEL_TIMEOUT = 1_000;
-const ATTEMPTS_LIMIT = 10;
-const isLegacyBridge = transport => transport.name === 'BridgeTransport' && !utils_1.versionUtils.isNewerOrEqual(transport.version, '3.0.0');
-const handshakeCancel = async ({
-  device,
-  logger,
-  signal
-}) => {
-  if (device.features || device.getThpState()?.properties) {
-    return;
-  }
-  const timeout = device.possibleT1 ? CANCEL_TIMEOUT : undefined;
-  logger?.debug('handshake Cancel start');
-  const send = await device.getCurrentSession().send('Cancel', {}, {
-    signal,
-    timeout
-  });
-  if (!send.success) {
-    logger?.debug(`handshake Cancel send error ${send.error}`);
-    return;
-  }
-  logger?.debug('handshake Cancel sent');
-  for (let attempt = 0; attempt < ATTEMPTS_LIMIT; ++attempt) {
-    logger?.debug(`handshake Cancel read attempt ${attempt}`);
-    const result = await device.getCurrentSession().receive({
-      signal,
-      timeout
-    });
-    if (!result.success && result.error.message === transport_1.TRANSPORT_ERROR.ABORTED_BY_TIMEOUT) {
-      if (isLegacyBridge(device.transport)) {
-        await (0, utils_1.resolveAfter)(501);
-      }
-      await device.acquire();
-    }
-    if (!result.success && result.error.message !== protocol_1.PROTOCOL_MALFORMED) {
-      logger?.debug(`handshake Cancel read error: ${result.error}`);
-      return;
-    } else if (result.success) {
-      logger?.debug(`handshake Cancel read success: ${result.payload.type}`);
-      if (result.payload.type === 'Failure' && result.payload.message.code === 'Failure_InvalidProtocol') {
-        logger?.debug(`handshake Cancel protocol v2 detected`);
-        await device.setupThp();
-      }
-      if (result.payload.type === 'Failure' && result.payload.message.code === 'Failure_Busy') {
-        throw (0, errors_1.TypedError)(result.payload.message.code, result.payload.message.message);
-      }
-      return;
-    }
-  }
-  logger?.debug(`handshake Cancel attempts limit reached`);
-};
-exports.handshakeCancel = handshakeCancel;
-//# sourceMappingURL=handshake.js.map

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

@@ -1,2 +0,0 @@
-export { validateState } from './validateState';
-//# sourceMappingURL=index.d.ts.map

package/lib/device/workflow/index.js

@@ -1,14 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.validateState = void 0;
-var validateState_1 = require("./validateState");
-Object.defineProperty(exports, "validateState", {
-  enumerable: true,
-  get: function () {
-    return validateState_1.validateState;
-  }
-});
-//# sourceMappingURL=index.js.map

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

@@ -1,3 +0,0 @@
-import { TpnWorkflowContext } from '../../types/workflow';
-export declare const trezorPushNotificationHandler: ({ device, message }: TpnWorkflowContext) => Promise<void>;
-//# sourceMappingURL=trezorPushNotification.d.ts.map