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

package/lib/device/TransportManager.js

@@ -1,144 +0,0 @@
-import { TRANSPORT } from "@trezor/transport-common";
-import { TypedEmitter, resolveAfter } from "@trezor/utils";
-const createOverrideLock = () => {
-  let promise;
-  let sequence = 0;
-  let abort;
-  let message;
-  const override = async (abortMessage, action) => {
-    message = abortMessage;
-    const seq = ++sequence;
-    while (promise) {
-      abort?.abort(new Error(abortMessage));
-      await promise.catch(() => {});
-    }
-    if (seq !== sequence) return Promise.reject(new Error(message));
-    abort = new AbortController();
-    promise = action(abort.signal).finally(() => {
-      abort = undefined;
-      promise = undefined;
-    });
-    return promise;
-  };
-  const getPending = () => promise;
-  return {
-    override,
-    getPending
-  };
-};
-export class TransportManager extends TypedEmitter {
-  lock = createOverrideLock();
-  transports = [];
-  activeTransport;
-  transportReconnect = false;
-  upgradeTimeout;
-  startTransport;
-  constructor(startTransport) {
-    super();
-    this.startTransport = startTransport;
-  }
-  pending() {
-    return this.lock.getPending();
-  }
-  get() {
-    return this.activeTransport;
-  }
-  init({
-    transports,
-    transportReconnect = false,
-    pendingTransportEvent = false
-  }) {
-    this.transports = transports;
-    this.transportReconnect = transportReconnect;
-    return this.lock.override('New init', signal => this.createInitPromise(pendingTransportEvent, signal));
-  }
-  dispose() {
-    this.removeAllListeners();
-    return this.lock.override('Disposing', () => {
-      const {
-        activeTransport
-      } = this;
-      if (activeTransport) {
-        clearTimeout(this.upgradeTimeout);
-        delete this.activeTransport;
-        activeTransport.stop();
-      }
-      return Promise.resolve();
-    });
-  }
-  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.code);
-  }
-  scheduleUpgradeCheck(pendingTransportEvent) {
-    clearTimeout(this.upgradeTimeout);
-    this.upgradeTimeout = setTimeout(async () => {
-      if (!this.activeTransport || this.activeTransport === this.transports[0]) return;
-      for (const t of this.transports) {
-        if (t === this.activeTransport) break;
-        if (await t.ping()) {
-          this.lock.override('Upgrading', signal => this.createInitPromise(pendingTransportEvent, signal)).catch(() => {});
-          return;
-        }
-      }
-      this.scheduleUpgradeCheck(pendingTransportEvent);
-    }, 1000);
-  }
-  async createInitPromise(pendingTransportEvent, abortSignal) {
-    try {
-      const {
-        transports,
-        activeTransport
-      } = this;
-      const transport = transports.length ? await this.selectTransport(transports, abortSignal) : undefined;
-      if (activeTransport !== transport) {
-        if (activeTransport) {
-          clearTimeout(this.upgradeTimeout);
-          delete this.activeTransport;
-          activeTransport.stop();
-        }
-        if (transport) {
-          try {
-            await this.startTransport(transport, pendingTransportEvent, abortSignal);
-          } catch (err) {
-            transport.stop();
-            throw err;
-          }
-          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 resolveAfter(1000, signal);
-                await this.createInitPromise(pendingTransportEvent, signal);
-              }
-            }).catch(() => {});
-          });
-          this.activeTransport = transport;
-          this.emit(TRANSPORT.START, transport);
-        } else {
-          this.emit(TRANSPORT.ERROR, 'Transport disabled');
-        }
-      }
-      if (transport && transport !== transports[0]) {
-        this.scheduleUpgradeCheck(pendingTransportEvent);
-      }
-    } catch (error) {
-      this.emit(TRANSPORT.ERROR, error?.message);
-      if (this.transportReconnect && !abortSignal.aborted) {
-        this.lock.override('Reconnecting', async signal => {
-          await resolveAfter(1000, signal);
-          await this.createInitPromise(pendingTransportEvent, signal);
-        }).catch(() => {});
-      }
-    }
-  }
-}

package/lib/device/calculateRevisionForDevice.d.ts

@@ -1,10 +0,0 @@
-import type { VersionArray } from '@trezor/utils/lib/versionUtils';
-type calculateRevisionForDeviceParams = {
-  commitRevision: string;
-  version: VersionArray;
-};
-export declare const calculateRevisionForDevice: ({
-  commitRevision,
-  version
-}: calculateRevisionForDeviceParams) => string;
-export {};

package/lib/device/calculateRevisionForDevice.js

@@ -1,19 +0,0 @@
-import { isNewer } from "@trezor/utils/lib/versionUtils.js";
-export const calculateRevisionForDevice = ({
-  commitRevision,
-  version
-}) => {
-  if (isNewer(version, '2.4.0')) {
-    return commitRevision;
-  }
-  if (isNewer(version, '2.2.0')) {
-    return commitRevision.slice(0, 9);
-  }
-  if (isNewer(version, '2.1.8')) {
-    return commitRevision;
-  }
-  if (isNewer(version, '2.0.0')) {
-    return commitRevision.slice(0, 8);
-  }
-  return commitRevision;
-};

package/lib/device/checkFirmwareRevision.d.ts

@@ -1,22 +0,0 @@
-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;
-  deviceBootloaderHash?: string | null;
-  expectedBootloaderHash: string | undefined;
-  firmwareType: FirmwareType;
-};
-export declare const checkFirmwareRevision: ({
-  firmwareVersion,
-  internalModel,
-  deviceRevision,
-  expectedRevision,
-  deviceBootloaderHash,
-  expectedBootloaderHash,
-  firmwareType
-}: CheckFirmwareRevisionParams) => Promise<FirmwareRevisionCheckResult>;

package/lib/device/checkFirmwareRevision.js

@@ -1,104 +0,0 @@
-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) || isBrowserOfflineError(e) || isAbortControllerTimeout(e);
-};
-const failFirmwareRevisionCheck = (error, errorPayload) => ({
-  success: false,
-  error,
-  ...(errorPayload ? {
-    errorPayload
-  } : null)
-});
-const doRevisionsMatch = ({
-  deviceRevision,
-  expectedCommitRevision,
-  firmwareVersion
-}) => {
-  if (!deviceRevision) {
-    return false;
-  }
-  const adjustedExpected = calculateRevisionForDevice({
-    commitRevision: expectedCommitRevision,
-    version: firmwareVersion
-  });
-  return adjustedExpected === deviceRevision;
-};
-export const checkFirmwareRevision = async ({
-  firmwareVersion,
-  internalModel,
-  deviceRevision,
-  expectedRevision,
-  deviceBootloaderHash,
-  expectedBootloaderHash,
-  firmwareType
-}) => {
-  if (expectedBootloaderHash && deviceBootloaderHash !== expectedBootloaderHash) {
-    return failFirmwareRevisionCheck('bootloader-hash-mismatch');
-  }
-  if (expectedRevision === undefined) {
-    if (!versionUtils.isVersionArray(firmwareVersion)) {
-      return failFirmwareRevisionCheck('firmware-version-unknown');
-    }
-    try {
-      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,
-        firmwareVersion
-      })) {
-        return failFirmwareRevisionCheck('revision-mismatch');
-      }
-      return {
-        success: true
-      };
-    } catch (e) {
-      if (isNotFoundError(e)) return failFirmwareRevisionCheck('firmware-version-unknown');
-      return isOfflineError(e) ? failFirmwareRevisionCheck('cannot-perform-check-offline') : failFirmwareRevisionCheck('other-error', serializeError(e));
-    }
-  }
-  if (!doRevisionsMatch({
-    deviceRevision,
-    expectedCommitRevision: expectedRevision,
-    firmwareVersion
-  })) {
-    return failFirmwareRevisionCheck('revision-mismatch');
-  }
-  return {
-    success: true
-  };
-};

package/lib/device/resolveDescriptorForTaproot.d.ts

@@ -1,17 +0,0 @@
-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;
-}
-export declare const resolveDescriptorForTaproot: ({
-  response,
-  publicKey
-}: ResolveDescriptorForTaprootParams) => {
-  xpub: string;
-  checksum: string;
-} | {
-  xpub: string;
-  checksum: undefined;
-};
-export {};

package/lib/device/resolveDescriptorForTaproot.js

@@ -1,27 +0,0 @@
-import { convertTaprootXpub, isNotNull, isNotNullOrUndefined } from "@trezor/utils";
-export const resolveDescriptorForTaproot = ({
-  response,
-  publicKey
-}) => {
-  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 (isNotNull(correctedXpub)) {
-      return {
-        xpub: correctedXpub,
-        checksum
-      };
-    }
-  }
-  const fingerprint = Number(publicKey.root_fingerprint || 0).toString(16).padStart(8, '0');
-  const descriptorPath = `${fingerprint}${response.serializedPath.substring(1)}`;
-  return {
-    xpub: `tr([${descriptorPath}]${response.xpub}/<0;1>/*)`,
-    checksum: undefined
-  };
-};

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

@@ -1,3 +0,0 @@
-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,100 +0,0 @@
-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 = protocolThp.getThpPairingMethod(dm);
-  const isRequested = settingsMethods?.find(sm => value === protocolThp.getThpPairingMethod(sm));
-  return isRequested ? value : [];
-});
-export const createThpChannel = async device => {
-  const thpState = device.getThpState();
-  if (!thpState) {
-    throw ERRORS.TypedError('Device_ThpStateMissing');
-  }
-  thpState.setChannel(protocolThp.constants.THP_DEFAULT_CHANNEL);
-  const nonce = Buffer.from(randomBytes(8));
-  const createChannel = await thpCall(device, 'ThpCreateChannelRequest', {
-    nonce
-  });
-  const {
-    properties,
-    ...resp
-  } = createChannel.message;
-  if (nonce.compare(resp.nonce) !== 0) {
-    throw new Error('Nonce not meet' + nonce.toString('hex') + ' ' + resp.nonce.toString('hex'));
-  }
-  const settings = settingsStore.get('thp');
-  const pairingMethods = getPairingMethods(properties.pairing_methods, settings?.pairingMethods);
-  if (!pairingMethods?.length) {
-    throw ERRORS.TypedError('Device_ThpPairingMethodsException');
-  }
-  thpState.setThpProperties(properties);
-  thpState.setChannel(resp.channel);
-  thpState.updateHandshakeCredentials({
-    pairingMethods,
-    handshakeHash: resp.handshakeHash
-  });
-};
-export const thpHandshake = async (device, unlockPin = false) => {
-  const thpState = device.getThpState();
-  if (!thpState?.handshakeCredentials) {
-    throw ERRORS.TypedError('Device_ThpStateMissing');
-  }
-  const settings = settingsStore.get('thp');
-  const knownCredentials = (settings?.knownCredentials || []).sort(cre => cre.autoconnect ? -1 : 1);
-  const tryToUnlock = unlockPin ? 1 : 0;
-  const hostEphemeralKeys = protocolThp.getCurve25519KeyPair(Buffer.from(randomBytes(32)));
-  const handshakeInit = await thpCall(device, 'ThpHandshakeInitRequest', {
-    key: hostEphemeralKeys.publicKey,
-    tryToUnlock
-  });
-  const {
-    trezorEncryptedStaticPubkey
-  } = handshakeInit.message;
-  const handshakeCredentials = protocolThp.handleHandshakeInit({
-    handshakeInitResponse: handshakeInit.message,
-    thpState,
-    hostEphemeralKeys,
-    knownCredentials,
-    tryToUnlock,
-    protobufEncoder: (name, data) => protobufManager.encode(name, data)
-  });
-  const {
-    hostKey,
-    trezorKey,
-    hostEncryptedStaticPubkey
-  } = handshakeCredentials;
-  thpState.updateHandshakeCredentials({
-    trezorEncryptedStaticPubkey,
-    hostEncryptedStaticPubkey,
-    handshakeHash: handshakeCredentials.handshakeHash,
-    trezorKey,
-    hostKey,
-    staticKey: handshakeCredentials.staticKey,
-    hostStaticPublicKey: handshakeCredentials.hostStaticKeys.publicKey
-  });
-  thpState.setPairingCredentials(handshakeCredentials.allCredentials);
-  const handshakeCompletion = await thpCall(device, 'ThpHandshakeCompletionRequest', {
-    hostPubkey: hostEncryptedStaticPubkey,
-    encryptedPayload: handshakeCredentials.encryptedPayload
-  });
-  if (!handshakeCompletion.message.state && handshakeCredentials.credentials) {
-    thpState.removePairingCredential(handshakeCredentials.credentials);
-    const {
-      credential
-    } = handshakeCredentials.credentials;
-    const index = settings?.knownCredentials?.findIndex(c => c.credential === credential) ?? -1;
-    if (index >= 0) {
-      settings?.knownCredentials?.splice(index, 1);
-    }
-  }
-  thpState.setIsPaired(handshakeCompletion.message.state !== 0);
-  thpState.setPhase('pairing');
-  if (thpState.isAutoconnectPaired || handshakeCompletion.message.state === 2) {
-    await thpCall(device, 'ThpEndRequest', {});
-    thpState.setPhase('paired');
-  }
-};

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

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

package/lib/device/thp/index.js

@@ -1,65 +0,0 @@
-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 createThpChannel(device);
-      try {
-        await thpHandshake(device);
-      } catch (error) {
-        const isPinLocked = error.code === 'ThpDeviceLocked';
-        const isTransportBusy = error.message === 'ThpTransportBusy';
-        if (!isPinLocked && !isTransportBusy) throw error;
-        thpState.resetState();
-        if (isPinLocked && !withInteraction) return 'pin-locked';
-        if (isPinLocked) {
-          device.emit(DEVICE.BUTTON, {
-            device,
-            payload: {
-              code: 'ButtonRequest_PinEntry'
-            }
-          });
-        }
-        await createThpChannel(device);
-        await thpHandshake(device, isPinLocked);
-      }
-    }
-    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;
-  }
-};

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

@@ -1,16 +0,0 @@
-import { thp as protocolThp } from '@trezor/protocol';
-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: IDevice) => Promise<{
-  type: "ThpEndResponse";
-  message: protocolThp.ThpEndResponse;
-}>;
-export declare const thpPairing: (device: IDevice) => Promise<{
-  type: "ThpEndResponse";
-  message: protocolThp.ThpEndResponse;
-} | undefined>;