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

package/libESM/device/TransportManager.mjs

@@ -1,142 +0,0 @@
-import { TRANSPORT } from "@trezor/transport";
-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([transport, ...rest], signal) {
-    if (signal.aborted) throw new Error(signal.reason);
-    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/libESM/device/calculateRevisionForDevice.d.mts

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

package/libESM/device/calculateRevisionForDevice.mjs

@@ -1,19 +0,0 @@
-import { isNewer } from "@trezor/utils/libESM/versionUtils.mjs";
-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/libESM/device/checkFirmwareRevision.d.mts

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

package/libESM/device/checkFirmwareRevision.mjs

@@ -1,75 +0,0 @@
-import { serializeError, versionUtils } from "@trezor/utils";
-import { calculateRevisionForDevice } from "./calculateRevisionForDevice.mjs";
-import { getOnlineReleaseByVersion } from "../data/firmwareInfo.mjs";
-import { HttpRequestError } from "../utils/assetUtils.mjs";
-const isNotFoundError = e => e instanceof HttpRequestError && e.response.status === 404;
-const isNodeJSOfflineError = e => ['FetchError', 'AbortError'].includes(e.name);
-const isReactNativeOfflineError = e => e.name === 'TypeError' && e.message.includes('Network request failed');
-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);
-};
-const failFirmwareRevisionCheck = (error, errorPayload) => ({
-  success: false,
-  error,
-  ...(errorPayload ? {
-    errorPayload
-  } : null)
-});
-const doRevisionsMatch = ({
-  deviceRevision,
-  expectedCommitRevision,
-  firmwareVersion
-}) => {
-  if (deviceRevision === null) {
-    return false;
-  }
-  const adjustedExpected = calculateRevisionForDevice({
-    commitRevision: expectedCommitRevision,
-    version: firmwareVersion
-  });
-  return adjustedExpected === deviceRevision;
-};
-export const checkFirmwareRevision = async ({
-  firmwareVersion,
-  internalModel,
-  deviceRevision,
-  expectedRevision,
-  firmwareType
-}) => {
-  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');
-      }
-      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/libESM/device/resolveDescriptorForTaproot.d.mts

@@ -1,14 +0,0 @@
-import type { HDNodeResponse } from '@trezor/connect-common/libESM/types/api/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/libESM/device/resolveDescriptorForTaproot.mjs

@@ -1,25 +0,0 @@
-import { convertTaprootXpub } from "@trezor/utils";
-export const resolveDescriptorForTaproot = ({
-  response,
-  publicKey
-}) => {
-  if (publicKey.descriptor !== null && publicKey.descriptor !== undefined) {
-    const [xpub, checksum] = publicKey.descriptor.split('#');
-    const correctedXpub = convertTaprootXpub({
-      xpub,
-      direction: 'h-to-apostrophe'
-    });
-    if (correctedXpub !== null) {
-      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/libESM/device/thp/handshake.d.mts

@@ -1,3 +0,0 @@
-import type { IDevice } from '../../types/idevice';
-export declare const createThpChannel: (device: IDevice) => Promise<void>;
-export declare const thpHandshake: (device: IDevice, unlockPin?: boolean) => Promise<void>;

package/libESM/device/thp/handshake.mjs

@@ -1,100 +0,0 @@
-import { randomBytes } from "crypto";
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { protobufManager } from "@trezor/protobuf";
-import { thp as protocolThp } from "@trezor/protocol";
-import { thpCall } from "./thpCall.mjs";
-import * as settingsStore from "../../data/settingsStore.mjs";
-const getPairingMethods = (deviceMethods, settingsMethods) => deviceMethods?.flatMap(dm => {
-  const value = protocolThp.getThpPairingMethod(dm);
-  const isRequested = settingsMethods && 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 = 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(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/libESM/device/thp/index.d.mts

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

package/libESM/device/thp/index.mjs

@@ -1,65 +0,0 @@
-import { DEVICE } from "@trezor/connect-common";
-import { createThpChannel, thpHandshake } from "./handshake.mjs";
-import { thpPairing } from "./pairing.mjs";
-export { abortThpWorkflow } from "./thpCall.mjs";
-export { getThpCredentials } from "./pairing.mjs";
-export { createThpSession } from "./session.mjs";
-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/libESM/device/thp/pairing.d.mts

@@ -1,16 +0,0 @@
-import { thp as protocolThp } from '@trezor/protocol';
-import type { IDevice } from '../../types/idevice';
-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>;