@trezor/connect 9.2.3 → 9.2.4-beta.1

package/lib/events/ui-request.d.ts

@@ -18,6 +18,7 @@ export declare const UI_REQUEST: {
     readonly FIRMWARE_NOT_COMPATIBLE: "ui-device_firmware_not_compatible";
     readonly FIRMWARE_NOT_INSTALLED: "ui-device_firmware_not_installed";
     readonly FIRMWARE_PROGRESS: "ui-firmware-progress";
+    readonly FIRMWARE_RECONNECT: "ui-firmware_reconnect";
     readonly DEVICE_NEEDS_BACKUP: "ui-device_needs_backup";
     readonly REQUEST_UI_WINDOW: "ui-request_window";
     readonly CLOSE_UI_WINDOW: "ui-close_window";
@@ -196,10 +197,21 @@ export interface FirmwareProgress {
     type: typeof UI_REQUEST.FIRMWARE_PROGRESS;
     payload: {
         device: Device;
+        operation: 'downloading' | 'flashing' | 'validating';
         progress: number;
     };
 }
-export type UiEvent = UiRequestWithoutPayload | UiRequestDeviceAction | UiRequestButton | UiRequestPermission | UiRequestConfirmation | UiRequestSelectDevice | UiRequestUnexpectedDeviceMode | UiRequestSelectAccount | UiRequestSelectFee | UpdateCustomFee | BundleProgress<any> | FirmwareProgress | FirmwareException | UiRequestAddressValidation | UiRequestSetOperation;
+export interface FirmwareReconnect {
+    type: typeof UI_REQUEST.FIRMWARE_RECONNECT;
+    payload: {
+        device: Device;
+        disconnected: boolean;
+        method: 'manual' | 'auto' | 'wait';
+        target: 'normal' | 'bootloader';
+        i: number;
+    };
+}
+export type UiEvent = UiRequestWithoutPayload | UiRequestDeviceAction | UiRequestButton | UiRequestPermission | UiRequestConfirmation | UiRequestSelectDevice | UiRequestUnexpectedDeviceMode | UiRequestSelectAccount | UiRequestSelectFee | UpdateCustomFee | BundleProgress<any> | FirmwareProgress | FirmwareException | FirmwareReconnect | UiRequestAddressValidation | UiRequestSetOperation;
 export type UiEventMessage = UiEvent & {
     event: typeof UI_EVENT;
 };

package/lib/events/ui-request.js

@@ -15,6 +15,7 @@ exports.UI_REQUEST = {
     FIRMWARE_NOT_COMPATIBLE: 'ui-device_firmware_not_compatible',
     FIRMWARE_NOT_INSTALLED: 'ui-device_firmware_not_installed',
     FIRMWARE_PROGRESS: 'ui-firmware-progress',
+    FIRMWARE_RECONNECT: 'ui-firmware_reconnect',
     DEVICE_NEEDS_BACKUP: 'ui-device_needs_backup',
     REQUEST_UI_WINDOW: 'ui-request_window',
     CLOSE_UI_WINDOW: 'ui-close_window',

package/lib/index.js

@@ -21,11 +21,11 @@ const manifest = (data) => {
         manifest: data,
     });
 };
-const dispose = async () => {
+const dispose = () => {
     exports.eventEmitter.removeAllListeners();
     _settings = (0, connectSettings_1.parseConnectSettings)();
     if (_core) {
-        await _core.dispose();
+        _core.dispose();
         _core = null;
     }
 };

package/lib/types/api/backupDevice.d.ts

@@ -1,4 +1,4 @@
 import type { PROTO } from '../../constants';
-import type { CommonParams, Response } from '../params';
-export declare function backupDevice(params?: CommonParams): Response<PROTO.Success>;
+import type { Params, Response } from '../params';
+export declare function backupDevice(params?: Params<PROTO.BackupDevice>): Response<PROTO.Success>;
 //# sourceMappingURL=backupDevice.d.ts.map

package/lib/types/api/dispose.d.ts

@@ -1,2 +1,2 @@
-export declare function dispose(): Promise<void>;
+export declare function dispose(): void;
 //# sourceMappingURL=dispose.d.ts.map

package/lib/types/api/firmwareUpdate.d.ts

@@ -3,16 +3,17 @@ import type { Params, Response } from '../params';
 export type FirmwareUpdate = Static<typeof FirmwareUpdate>;
 export declare const FirmwareUpdate: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
     binary: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
-    version: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>;
     btcOnly: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
     baseUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    intermediaryVersion: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<1>, import("@sinclair/typebox").TLiteral<2>, import("@sinclair/typebox").TLiteral<3>]>>;
+    language: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>, import("@sinclair/typebox").TObject<{
     binary: import("@trezor/schema-utils/lib/custom-types/array-buffer").TArrayBuffer;
 }>]>;
-export interface FirmwareUpdateResponse {
-    hash: string;
-    challenge: string;
-}
+export type FirmwareUpdateResponse = {
+    check: 'mismatch' | 'valid' | 'omitted';
+} | {
+    check: 'other-error';
+    checkError: string;
+};
 export declare function firmwareUpdate(params: Params<FirmwareUpdate>): Response<FirmwareUpdateResponse>;
 //# sourceMappingURL=firmwareUpdate.d.ts.map

package/lib/types/api/firmwareUpdate.js

@@ -2,14 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FirmwareUpdate = void 0;
 const schema_utils_1 = require("@trezor/schema-utils");
-const firmware_1 = require("../firmware");
 exports.FirmwareUpdate = schema_utils_1.Type.Union([
     schema_utils_1.Type.Object({
         binary: schema_utils_1.Type.Optional(schema_utils_1.Type.Undefined()),
-        version: schema_utils_1.Type.Array(schema_utils_1.Type.Number(), { minItems: 3, maxItems: 3 }),
         btcOnly: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
         baseUrl: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-        intermediaryVersion: schema_utils_1.Type.Optional(firmware_1.IntermediaryVersion),
+        language: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
     }),
     schema_utils_1.Type.Object({
         binary: schema_utils_1.Type.ArrayBuffer(),

package/lib/utils/popupPromiseManager.d.ts

@@ -0,0 +1,8 @@
+export declare const createPopupPromiseManager: () => {
+    wait: () => Promise<void>;
+    isWaiting: () => boolean;
+    clear: () => void;
+    resolve: () => void;
+    reject: (error: Error) => void;
+};
+//# sourceMappingURL=popupPromiseManager.d.ts.map

package/lib/utils/popupPromiseManager.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPopupPromiseManager = void 0;
+const utils_1 = require("@trezor/utils");
+const createPopupPromiseManager = () => {
+    let _popupPromise;
+    const ensure = () => _popupPromise !== null && _popupPromise !== void 0 ? _popupPromise : (_popupPromise = (0, utils_1.createDeferred)());
+    const wait = () => ensure().promise;
+    const resolve = () => ensure().resolve();
+    const isWaiting = () => !!_popupPromise;
+    const reject = (error) => {
+        _popupPromise === null || _popupPromise === void 0 ? void 0 : _popupPromise.reject(error);
+        _popupPromise = undefined;
+    };
+    const clear = () => {
+        _popupPromise = undefined;
+    };
+    return { wait, isWaiting, clear, resolve, reject };
+};
+exports.createPopupPromiseManager = createPopupPromiseManager;
+//# sourceMappingURL=popupPromiseManager.js.map

package/lib/utils/uiPromiseManager.d.ts

@@ -0,0 +1,38 @@
+import { UiPromiseCreator, UiPromiseResponse } from '../events';
+export declare const createUiPromiseManager: (interactionTimeout: () => void) => {
+    exists: (type: UiPromiseResponse['type']) => boolean;
+    create: UiPromiseCreator;
+    resolve: (event: UiPromiseResponse) => boolean;
+    rejectAll: (error: Error) => void;
+    disconnected: (devicePath: string) => boolean;
+    get: <T extends "device-disconnect" | "popup-handshake" | "ui-receive_permission" | "ui-receive_confirmation" | "ui-receive_pin" | "ui-receive_passphrase" | "ui-receive_device" | "ui-receive_account" | "ui-receive_fee" | "ui-receive_word" | "ui-invalid_passphrase_action" | "ui-login_challenge_response">(type: T) => Promise<Extract<import("../events").UiResponsePopupHandshake, {
+        type: T;
+    }> | Extract<import("../events").UiResponsePermission, {
+        type: T;
+    }> | Extract<import("../events").UiResponseConfirmation, {
+        type: T;
+    }> | Extract<import("../events").UiResponseDevice, {
+        type: T;
+    }> | Extract<import("../events").UiResponsePin, {
+        type: T;
+    }> | Extract<import("../events").UiResponseWord, {
+        type: T;
+    }> | Extract<import("../events").UiResponsePassphrase, {
+        type: T;
+    }> | Extract<import("../events").UiResponsePassphraseAction, {
+        type: T;
+    }> | Extract<import("../events").UiResponseAccount, {
+        type: T;
+    }> | Extract<import("../events").UiResponseFee, {
+        type: T;
+    }> | Extract<import("../events").UiResponseLoginChallenge, {
+        type: T;
+    }> | Extract<{
+        type: "device-disconnect";
+        payload?: undefined;
+    }, {
+        type: T;
+    }>>;
+    clear: () => void;
+};
+//# sourceMappingURL=uiPromiseManager.d.ts.map

package/lib/utils/uiPromiseManager.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUiPromiseManager = void 0;
+const events_1 = require("../events");
+const utils_1 = require("@trezor/utils");
+const createUiPromiseManager = (interactionTimeout) => {
+    let _uiPromises = [];
+    const exists = (type) => _uiPromises.some(p => p.id === type);
+    const create = (promiseEvent, device) => {
+        const uiPromise = {
+            ...(0, utils_1.createDeferred)(promiseEvent),
+            device,
+        };
+        _uiPromises.push(uiPromise);
+        interactionTimeout();
+        return uiPromise;
+    };
+    const resolve = (event) => {
+        const uiPromise = _uiPromises.find(p => p.id === event.type);
+        if (!uiPromise)
+            return false;
+        uiPromise.resolve(event);
+        _uiPromises = _uiPromises.filter(p => p !== uiPromise);
+        return true;
+    };
+    const rejectAll = (error) => {
+        _uiPromises.forEach(p => p.reject(error));
+        _uiPromises = [];
+    };
+    const disconnected = (devicePath) => {
+        const [toResolve, toKeep] = (0, utils_1.arrayPartition)(_uiPromises, (p) => { var _a; return ((_a = p.device) === null || _a === void 0 ? void 0 : _a.getDevicePath()) === devicePath && p.id === events_1.DEVICE.DISCONNECT; });
+        toResolve.forEach(p => p.resolve({ type: events_1.DEVICE.DISCONNECT }));
+        _uiPromises = toKeep;
+        return !!toResolve.length || toKeep.some(p => { var _a; return ((_a = p.device) === null || _a === void 0 ? void 0 : _a.getDevicePath()) === devicePath; });
+    };
+    const get = (type) => {
+        var _a;
+        const uiPromise = _uiPromises.find(p => p.id === type);
+        return (_a = uiPromise === null || uiPromise === void 0 ? void 0 : uiPromise.promise) !== null && _a !== void 0 ? _a : Promise.reject(new Error(`UiPromise ${type} doesn't exist`));
+    };
+    const clear = () => {
+        _uiPromises = [];
+    };
+    return { exists, create, resolve, rejectAll, disconnected, get, clear };
+};
+exports.createUiPromiseManager = createUiPromiseManager;
+//# sourceMappingURL=uiPromiseManager.js.map

package/lib/workers/workers-browser.d.ts

@@ -1,7 +1,9 @@
 import BlockbookWorker from '@trezor/blockchain-link/lib/workers/blockbook';
 import RippleWorker from '@trezor/blockchain-link/lib/workers/ripple';
 import BlockfrostWorker from '@trezor/blockchain-link/lib/workers/blockfrost';
-import SolanaWorker from '@trezor/blockchain-link/lib/workers/solana';
+import type { BaseWorker } from '@trezor/blockchain-link/lib/workers/baseWorker';
+type WorkerAsyncImporter = () => Promise<BaseWorker<unknown>>;
+declare const SolanaWorker: WorkerAsyncImporter;
 declare const ElectrumWorker: undefined;
 export { BlockbookWorker, RippleWorker, BlockfrostWorker, ElectrumWorker, SolanaWorker };
 //# sourceMappingURL=workers-browser.d.ts.map

package/lib/workers/workers-browser.js

@@ -8,8 +8,8 @@ const ripple_1 = tslib_1.__importDefault(require("@trezor/blockchain-link/lib/wo
 exports.RippleWorker = ripple_1.default;
 const blockfrost_1 = tslib_1.__importDefault(require("@trezor/blockchain-link/lib/workers/blockfrost"));
 exports.BlockfrostWorker = blockfrost_1.default;
-const solana_1 = tslib_1.__importDefault(require("@trezor/blockchain-link/lib/workers/solana"));
-exports.SolanaWorker = solana_1.default;
+const SolanaWorker = () => Promise.resolve().then(() => tslib_1.__importStar(require('@trezor/blockchain-link/lib/workers/solana'))).then(w => w.default());
+exports.SolanaWorker = SolanaWorker;
 const ElectrumWorker = undefined;
 exports.ElectrumWorker = ElectrumWorker;
 //# sourceMappingURL=workers-browser.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trezor/connect",
-  "version": "9.2.3",
+  "version": "9.2.4-beta.1",
   "author": "Trezor <info@trezor.io>",
   "homepage": "https://github.com/trezor/trezor-suite/tree/develop/packages/connect",
   "description": "High-level javascript interface for Trezor hardware wallet.",
@@ -71,12 +71,12 @@
     "@ethereumjs/tx": "^5.2.1",
     "@fivebinaries/coin-selection": "2.2.1",
     "@trezor/blockchain-link": "2.1.29",
-    "@trezor/blockchain-link-types": "1.0.16",
+    "@trezor/blockchain-link-types": "1.0.17-beta.1",
     "@trezor/connect-analytics": "1.0.14",
-    "@trezor/connect-common": "0.0.32",
-    "@trezor/protobuf": "1.0.12",
-    "@trezor/protocol": "1.0.8",
-    "@trezor/schema-utils": "1.0.3",
+    "@trezor/connect-common": "0.0.33-beta.1",
+    "@trezor/protobuf": "1.0.13-beta.1",
+    "@trezor/protocol": "1.0.9-beta.1",
+    "@trezor/schema-utils": "1.0.4-beta.1",
     "@trezor/transport": "1.1.28",
     "@trezor/utils": "9.0.23",
     "@trezor/utxo-lib": "2.0.9",

package/lib/api/firmwareUpdate.d.ts

@@ -1,19 +0,0 @@
-import { AbstractMethod } from '../core/AbstractMethod';
-import { IntermediaryVersion } from '../types';
-type Params = {
-    binary?: ArrayBuffer;
-    version?: number[];
-    btcOnly?: boolean;
-    baseUrl: string;
-    intermediaryVersion?: IntermediaryVersion;
-};
-export default class FirmwareUpdate extends AbstractMethod<'firmwareUpdate', Params> {
-    init(): void;
-    confirmation(): Promise<boolean>;
-    run(): Promise<{
-        hash: string;
-        challenge: string;
-    }>;
-}
-export {};
-//# sourceMappingURL=firmwareUpdate.d.ts.map

package/lib/api/firmwareUpdate.js

@@ -1,78 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const crypto_1 = require("crypto");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const constants_1 = require("../constants");
-const events_1 = require("../events");
-const firmware_1 = require("./firmware");
-const firmwareInfo_1 = require("../data/firmwareInfo");
-const schema_utils_1 = require("@trezor/schema-utils");
-const firmwareUpdate_1 = require("../types/api/firmwareUpdate");
-class FirmwareUpdate extends AbstractMethod_1.AbstractMethod {
-    init() {
-        this.useEmptyPassphrase = true;
-        this.requiredPermissions = ['management'];
-        this.allowDeviceMode = [events_1.UI.BOOTLOADER, events_1.UI.INITIALIZE];
-        this.requireDeviceMode = [events_1.UI.BOOTLOADER];
-        this.useDeviceState = false;
-        this.skipFirmwareCheck = true;
-        const { payload } = this;
-        (0, schema_utils_1.Assert)(firmwareUpdate_1.FirmwareUpdate, payload);
-        if (payload.binary) {
-            this.params = {
-                ...this.params,
-                binary: payload.binary,
-            };
-        }
-        else {
-            this.params = {
-                version: payload.version,
-                btcOnly: payload.btcOnly,
-                baseUrl: payload.baseUrl || 'https://data.trezor.io',
-                intermediaryVersion: payload.intermediaryVersion,
-            };
-        }
-    }
-    async confirmation() {
-        await this.getPopupPromise().promise;
-        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
-        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
-            view: 'device-management',
-            customConfirmButton: {
-                className: 'wipe',
-                label: 'Proceed',
-            },
-            label: 'Do you want to update firmware? Never do this without your recovery card.',
-        }));
-        const uiResp = await uiPromise.promise;
-        return uiResp.payload;
-    }
-    async run() {
-        var _a;
-        const { device, params } = this;
-        let binary;
-        try {
-            if (params.binary) {
-                binary = params.binary;
-            }
-            else {
-                binary = await (0, firmware_1.getBinary)({
-                    features: device.features,
-                    releases: (0, firmwareInfo_1.getReleases)((_a = device.features) === null || _a === void 0 ? void 0 : _a.internal_model),
-                    version: params.version,
-                    btcOnly: params.btcOnly,
-                    baseUrl: params.baseUrl,
-                    intermediaryVersion: params.intermediaryVersion,
-                });
-            }
-        }
-        catch (err) {
-            throw constants_1.ERRORS.TypedError('Method_FirmwareUpdate_DownloadFailed', `Failed to download firmware binary ${err.message}`);
-        }
-        const stripped = (0, firmware_1.stripFwHeaders)(binary);
-        await (0, firmware_1.uploadFirmware)(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, { payload: (0, firmware_1.shouldStripFwHeaders)(device.features) ? stripped : binary });
-        return (0, firmware_1.calculateFirmwareHash)(device.features.major_version, stripped, (0, crypto_1.randomBytes)(32));
-    }
-}
-exports.default = FirmwareUpdate;
-//# sourceMappingURL=firmwareUpdate.js.map