@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/lib/device/TransportManager.d.ts

@@ -1,30 +0,0 @@
-import { TRANSPORT, Transport } from '@trezor/transport';
-import { TypedEmitter } from '@trezor/utils';
-type TransportManagerEvents = {
-    [TRANSPORT.START]: Transport;
-    [TRANSPORT.ERROR]: string;
-};
-type StartTransport = (transport: Transport, pendingTransportEvent: boolean, signal: AbortSignal) => Promise<void>;
-type InitParams = {
-    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;
-}
-export {};
-//# sourceMappingURL=TransportManager.d.ts.map

package/lib/device/TransportManager.js

@@ -1,150 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.TransportManager = void 0;
-const transport_1 = require("@trezor/transport");
-const utils_1 = require("@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
-  };
-};
-class TransportManager extends utils_1.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);
-  }
-  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_1.TRANSPORT.ERROR, error => {
-            this.emit(transport_1.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 this.createInitPromise(pendingTransportEvent, signal);
-              }
-            }).catch(() => {});
-          });
-          this.activeTransport = transport;
-          this.emit(transport_1.TRANSPORT.START, transport);
-        } else {
-          this.emit(transport_1.TRANSPORT.ERROR, 'Transport disabled');
-        }
-      }
-      if (transport && transport !== transports[0]) {
-        this.scheduleUpgradeCheck(pendingTransportEvent);
-      }
-    } catch (error) {
-      this.emit(transport_1.TRANSPORT.ERROR, error?.message);
-      if (this.transportReconnect && !abortSignal.aborted) {
-        this.lock.override('Reconnecting', async signal => {
-          await (0, utils_1.resolveAfter)(1000, signal);
-          await this.createInitPromise(pendingTransportEvent, signal);
-        }).catch(() => {});
-      }
-    }
-  }
-}
-exports.TransportManager = TransportManager;
-//# sourceMappingURL=TransportManager.js.map

package/lib/device/calculateRevisionForDevice.d.ts

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

package/lib/device/calculateRevisionForDevice.js

@@ -1,27 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.calculateRevisionForDevice = void 0;
-const versionUtils_1 = require("@trezor/utils/lib/versionUtils");
-const calculateRevisionForDevice = ({
-  commitRevision,
-  version
-}) => {
-  if ((0, versionUtils_1.isNewer)(version, '2.4.0')) {
-    return commitRevision;
-  }
-  if ((0, versionUtils_1.isNewer)(version, '2.2.0')) {
-    return commitRevision.slice(0, 9);
-  }
-  if ((0, versionUtils_1.isNewer)(version, '2.1.8')) {
-    return commitRevision;
-  }
-  if ((0, versionUtils_1.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 +0,0 @@
-import type { FirmwareType, VersionArray } from '@trezor/device-utils';
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import { FirmwareRevisionCheckResult } from '../types/device';
-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>;
-//# sourceMappingURL=checkFirmwareRevision.d.ts.map

package/lib/device/checkFirmwareRevision.js

@@ -1,83 +0,0 @@
-"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);
-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 = (0, calculateRevisionForDevice_1.calculateRevisionForDevice)({
-    commitRevision: expectedCommitRevision,
-    version: firmwareVersion
-  });
-  return adjustedExpected === deviceRevision;
-};
-const checkFirmwareRevision = async ({
-  firmwareVersion,
-  internalModel,
-  deviceRevision,
-  expectedRevision,
-  firmwareType
-}) => {
-  if (expectedRevision === undefined) {
-    if (!utils_1.versionUtils.isVersionArray(firmwareVersion)) {
-      return failFirmwareRevisionCheck('firmware-version-unknown');
-    }
-    try {
-      const onlineRelease = await (0, firmwareInfo_1.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', (0, utils_1.serializeError)(e));
-    }
-  }
-  if (!doRevisionsMatch({
-    deviceRevision,
-    expectedCommitRevision: expectedRevision,
-    firmwareVersion
-  })) {
-    return failFirmwareRevisionCheck('revision-mismatch');
-  }
-  return {
-    success: true
-  };
-};
-exports.checkFirmwareRevision = checkFirmwareRevision;
-//# sourceMappingURL=checkFirmwareRevision.js.map

package/lib/device/resolveDescriptorForTaproot.d.ts

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

package/lib/device/resolveDescriptorForTaproot.js

@@ -1,33 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.resolveDescriptorForTaproot = void 0;
-const utils_1 = require("@trezor/utils");
-const resolveDescriptorForTaproot = ({
-  response,
-  publicKey
-}) => {
-  if (publicKey.descriptor !== null && publicKey.descriptor !== undefined) {
-    const [xpub, checksum] = publicKey.descriptor.split('#');
-    const correctedXpub = (0, utils_1.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
-  };
-};
-exports.resolveDescriptorForTaproot = resolveDescriptorForTaproot;
-//# sourceMappingURL=resolveDescriptorForTaproot.js.map

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

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

package/lib/device/thp/handshake.js

@@ -1,112 +0,0 @@
-"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");
-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));
-  return isRequested ? value : [];
-});
-const createThpChannel = async device => {
-  const thpState = device.getThpState();
-  if (!thpState) {
-    throw constants_1.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', {
-    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 = DataManager_1.DataManager.getSettings('thp');
-  const pairingMethods = getPairingMethods(properties.pairing_methods, settings?.pairingMethods);
-  if (!pairingMethods?.length) {
-    throw constants_1.ERRORS.TypedError('Device_ThpPairingMethodsException');
-  }
-  thpState.setThpProperties(properties);
-  thpState.setChannel(resp.channel);
-  thpState.updateHandshakeCredentials({
-    pairingMethods,
-    handshakeHash: resp.handshakeHash
-  });
-};
-exports.createThpChannel = createThpChannel;
-const thpHandshake = async (device, unlockPin = false) => {
-  const thpState = device.getThpState();
-  if (!thpState?.handshakeCredentials) {
-    throw constants_1.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 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', {
-    key: hostEphemeralKeys.publicKey,
-    tryToUnlock
-  });
-  const {
-    trezorEncryptedStaticPubkey
-  } = handshakeInit.message;
-  const handshakeCredentials = protocol_1.thp.handleHandshakeInit({
-    handshakeInitResponse: handshakeInit.message,
-    thpState,
-    hostStaticKeys,
-    hostEphemeralKeys,
-    knownCredentials,
-    tryToUnlock,
-    protobufEncoder: (name, data) => (0, protobuf_1.encodeMessage)(device.transport.getMessages(), name, data)
-  });
-  const {
-    hostKey,
-    trezorKey,
-    hostEncryptedStaticPubkey
-  } = handshakeCredentials;
-  thpState.updateHandshakeCredentials({
-    trezorEncryptedStaticPubkey,
-    hostEncryptedStaticPubkey,
-    handshakeHash: handshakeCredentials.handshakeHash,
-    trezorKey,
-    hostKey,
-    staticKey,
-    hostStaticPublicKey: hostStaticKeys.publicKey
-  });
-  thpState.setPairingCredentials(handshakeCredentials.allCredentials);
-  const handshakeCompletion = await (0, thpCall_1.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 (0, thpCall_1.thpCall)(device, 'ThpEndRequest', {});
-    thpState.setPhase('paired');
-  }
-};
-exports.thpHandshake = thpHandshake;
-//# sourceMappingURL=handshake.js.map

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

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

package/lib/device/thp/index.js

@@ -1,69 +0,0 @@
-"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) => {
-  const thpState = device.getThpState();
-  if (!thpState) return;
-  try {
-    if (thpState.phase === 'handshake') {
-      await (0, handshake_1.createThpChannel)(device);
-      try {
-        await (0, handshake_1.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_1.DEVICE.BUTTON, {
-            device,
-            payload: {
-              code: 'ButtonRequest_PinEntry'
-            }
-          });
-        }
-        await (0, handshake_1.createThpChannel)(device);
-        await (0, handshake_1.thpHandshake)(device, isPinLocked);
-      }
-    }
-    if (thpState.phase === 'pairing' && withInteraction) {
-      await (0, pairing_1.thpPairing)(device);
-    }
-    if (thpState.phase !== 'paired') {
-      return 'thp-locked';
-    }
-  } catch (error) {
-    thpState.resetState();
-    throw error;
-  }
-};
-exports.getThpChannel = getThpChannel;
-//# sourceMappingURL=index.js.map

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

@@ -1,16 +0,0 @@
-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;
-}>;
-export declare const thpPairingEnd: (device: Device) => Promise<{
-    type: "ThpEndResponse";
-    message: protocolThp.ThpEndResponse;
-}>;
-export declare const thpPairing: (device: Device) => Promise<{
-    type: "ThpEndResponse";
-    message: protocolThp.ThpEndResponse;
-} | undefined>;
-//# sourceMappingURL=pairing.d.ts.map