@trezor/connect 9.6.5-beta.2 → 9.7.0-beta.2

package/lib/device/TransportManager.js

@@ -1,154 +1,150 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+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 };
+  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) {
+  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);
-        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);
-            }
+        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();
         }
-        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(() => { });
-            }
+        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.js

@@ -1,21 +1,27 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+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);
-    }
+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.js

@@ -1,70 +1,83 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+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.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 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),
+  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 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));
-        }
+const checkFirmwareRevision = async ({
+  firmwareVersion,
+  internalModel,
+  deviceRevision,
+  expectedRevision,
+  firmwareType
+}) => {
+  if (expectedRevision === undefined) {
+    if (!utils_1.versionUtils.isVersionArray(firmwareVersion)) {
+      return failFirmwareRevisionCheck('firmware-version-unknown');
     }
-    if (!doRevisionsMatch({
+    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: expectedRevision,
-        firmwareVersion,
-    })) {
+        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));
     }
-    return { success: true };
+  }
+  if (!doRevisionsMatch({
+    deviceRevision,
+    expectedCommitRevision: expectedRevision,
+    firmwareVersion
+  })) {
+    return failFirmwareRevisionCheck('revision-mismatch');
+  }
+  return {
+    success: true
+  };
 };
 exports.checkFirmwareRevision = checkFirmwareRevision;
 //# sourceMappingURL=checkFirmwareRevision.js.map

package/lib/device/resolveDescriptorForTaproot.js

@@ -1,23 +1,33 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+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 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,
-    };
+  }
+  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