@trezor/connect 9.4.3-beta.1 → 9.4.3

package/lib/types/device.d.ts

@@ -1,3 +1,4 @@
+import { Descriptor } from '@trezor/transport';
 import type { PROTO } from '../constants';
 import type { ReleaseInfo } from './firmware';
 export type DeviceStatus = 'available' | 'occupied' | 'used';
@@ -12,6 +13,7 @@ export type StaticSessionId = `${string}@${string}:${number}`;
 export type DeviceState = {
     sessionId?: string;
     staticSessionId?: StaticSessionId;
+    deriveCardano?: boolean;
 };
 export type UnavailableCapabilities = {
     [key: string]: UnavailableCapability;
@@ -30,8 +32,12 @@ export type FirmwareHashCheckResult = {
     success: false;
     error: FirmwareHashCheckError;
 };
+export type DeviceUniquePath = string & {
+    __type: 'DeviceUniquePath';
+};
+export declare const DeviceUniquePath: (id: string) => DeviceUniquePath;
 type BaseDevice = {
-    path: string;
+    path: DeviceUniquePath;
     name: string;
 };
 export type KnownDevice = BaseDevice & {
@@ -54,6 +60,8 @@ export type KnownDevice = BaseDevice & {
         firmwareRevision: FirmwareRevisionCheckResult | null;
         firmwareHash: FirmwareHashCheckResult | null;
     };
+    transportSessionOwner?: undefined;
+    transportDescriptorType?: typeof undefined;
 };
 export type UnknownDevice = BaseDevice & {
     type: 'unacquired';
@@ -71,6 +79,8 @@ export type UnknownDevice = BaseDevice & {
     state?: typeof undefined;
     unavailableCapabilities?: typeof undefined;
     availableTranslations?: typeof undefined;
+    transportSessionOwner?: string;
+    transportDescriptorType?: typeof undefined;
 };
 export type UnreadableDevice = BaseDevice & {
     type: 'unreadable';
@@ -88,6 +98,8 @@ export type UnreadableDevice = BaseDevice & {
     state?: typeof undefined;
     unavailableCapabilities?: typeof undefined;
     availableTranslations?: typeof undefined;
+    transportSessionOwner?: undefined;
+    transportDescriptorType: Descriptor['type'];
 };
 export type Device = KnownDevice | UnknownDevice | UnreadableDevice;
 export type Features = PROTO.Features;

package/lib/types/device.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeviceModelInternal = exports.FirmwareType = void 0;
+exports.DeviceModelInternal = exports.DeviceUniquePath = exports.FirmwareType = void 0;
 var FirmwareType;
 (function (FirmwareType) {
     FirmwareType["BitcoinOnly"] = "bitcoin-only";
     FirmwareType["Regular"] = "regular";
 })(FirmwareType || (exports.FirmwareType = FirmwareType = {}));
+const DeviceUniquePath = (id) => id;
+exports.DeviceUniquePath = DeviceUniquePath;
 var protobuf_1 = require("@trezor/protobuf");
 Object.defineProperty(exports, "DeviceModelInternal", { enumerable: true, get: function () { return protobuf_1.DeviceModelInternal; } });
 //# sourceMappingURL=device.js.map

package/lib/types/fees.d.ts

@@ -1,30 +1,30 @@
 import { Static } from '@trezor/schema-utils';
 export type FeeInfo = Static<typeof FeeInfo>;
 export declare const FeeInfo: import("@trezor/schema-utils").TObject<{
-    blockTime: import("@sinclair/typebox").TNumber;
-    minFee: import("@sinclair/typebox").TNumber;
-    maxFee: import("@sinclair/typebox").TNumber;
-    dustLimit: import("@sinclair/typebox").TNumber;
+    blockTime: import("@trezor/schema-utils").TNumber;
+    minFee: import("@trezor/schema-utils").TNumber;
+    maxFee: import("@trezor/schema-utils").TNumber;
+    dustLimit: import("@trezor/schema-utils").TNumber;
 }>;
 export type FeeLevel = Static<typeof FeeLevel>;
 export declare const FeeLevel: import("@trezor/schema-utils").TObject<{
-    label: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"high">, import("@sinclair/typebox").TLiteral<"normal">, import("@sinclair/typebox").TLiteral<"economy">, import("@sinclair/typebox").TLiteral<"low">, import("@sinclair/typebox").TLiteral<"custom">]>;
-    feePerUnit: import("@sinclair/typebox").TString;
-    blocks: import("@sinclair/typebox").TNumber;
-    feeLimit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    feePerTx: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    label: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TLiteral<"high">, import("@trezor/schema-utils").TLiteral<"normal">, import("@trezor/schema-utils").TLiteral<"economy">, import("@trezor/schema-utils").TLiteral<"low">, import("@trezor/schema-utils").TLiteral<"custom">]>;
+    feePerUnit: import("@trezor/schema-utils").TString;
+    blocks: import("@trezor/schema-utils").TNumber;
+    feeLimit: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+    feePerTx: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
 }>;
 export type SelectFeeLevel = Static<typeof SelectFeeLevel>;
-export declare const SelectFeeLevel: import("@sinclair/typebox").TUnion<[import("@trezor/schema-utils").TObject<{
-    name: import("@sinclair/typebox").TString;
-    fee: import("@sinclair/typebox").TLiteral<"0">;
-    feePerByte: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
-    disabled: import("@sinclair/typebox").TLiteral<true>;
+export declare const SelectFeeLevel: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TObject<{
+    name: import("@trezor/schema-utils").TString;
+    fee: import("@trezor/schema-utils").TLiteral<"0">;
+    feePerByte: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUndefined>;
+    disabled: import("@trezor/schema-utils").TLiteral<true>;
 }>, import("@trezor/schema-utils").TObject<{
-    name: import("@sinclair/typebox").TString;
-    fee: import("@sinclair/typebox").TString;
-    feePerByte: import("@sinclair/typebox").TString;
-    minutes: import("@sinclair/typebox").TNumber;
-    total: import("@sinclair/typebox").TString;
+    name: import("@trezor/schema-utils").TString;
+    fee: import("@trezor/schema-utils").TString;
+    feePerByte: import("@trezor/schema-utils").TString;
+    minutes: import("@trezor/schema-utils").TNumber;
+    total: import("@trezor/schema-utils").TString;
 }>]>;
 //# sourceMappingURL=fees.d.ts.map

package/lib/types/firmware.d.ts

@@ -21,7 +21,7 @@ export type FirmwareRelease = {
     translations?: string[];
 };
 export type IntermediaryVersion = 1 | 2 | 3;
-export declare const IntermediaryVersion: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<1>, import("@sinclair/typebox").TLiteral<2>, import("@sinclair/typebox").TLiteral<3>]>;
+export declare const IntermediaryVersion: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TLiteral<1>, import("@trezor/schema-utils").TLiteral<2>, import("@trezor/schema-utils").TLiteral<3>]>;
 export type ReleaseInfo = {
     changelog: FirmwareRelease[] | null;
     release: FirmwareRelease;

package/lib/types/params.d.ts

@@ -1,13 +1,15 @@
 import { TSchema, Static } from '@trezor/schema-utils';
-import { DeviceState } from './device';
+import { DeviceState, DeviceUniquePath } from './device';
 import { ErrorCode } from '../constants/errors';
 export interface DeviceIdentity {
-    path?: string;
-    state?: string | DeviceState;
+    path?: DeviceUniquePath;
+    state?: DeviceState;
     instance?: number;
 }
 export interface CommonParams {
-    device?: DeviceIdentity;
+    device?: DeviceIdentity & {
+        state?: DeviceState | string;
+    };
     useEmptyPassphrase?: boolean;
     useEventListener?: boolean;
     allowSeedlessDevice?: boolean;
@@ -16,6 +18,7 @@ export interface CommonParams {
     skipFinalReload?: boolean;
     useCardanoDerivation?: boolean;
     chunkify?: boolean;
+    __info?: boolean;
 }
 export type Params<T> = CommonParams & T & {
     bundle?: undefined;
@@ -24,7 +27,7 @@ interface Bundle<T> {
     bundle: T[];
 }
 export declare const Bundle: <T extends TSchema>(type: T) => import("@trezor/schema-utils").TObject<{
-    bundle: import("@sinclair/typebox").TArray<T>;
+    bundle: import("@trezor/schema-utils").TArray<T>;
 }>;
 export type BundledParams<T> = CommonParams & Bundle<T>;
 export interface CommonParamsWithCoin extends CommonParams {
@@ -47,7 +50,7 @@ export interface SuccessWithDevice<T> extends Success<T> {
 }
 export type Response<T> = Promise<SuccessWithDevice<T> | Unsuccessful>;
 export type DerivationPath = string | number[];
-export declare const DerivationPath: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>;
+export declare const DerivationPath: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>]>;
 type ProtoWithExtendedAddressN<T, A, R> = Omit<Extract<T, {
     address_n: A;
 }>, 'address_n'> & {
@@ -60,11 +63,11 @@ export type ProtoWithDerivationPath<T> = ProtoWithoutAddressN<T, number[]> | Pro
 export type ProtoWithAddressN<P extends ProtoWithDerivationPath<any>> = P extends ProtoWithDerivationPath<infer T> ? T : unknown;
 export type GetAddress = Static<typeof GetAddress>;
 export declare const GetAddress: import("@trezor/schema-utils").TObject<{
-    path: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>;
-    address: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    showOnTrezor: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-    chunkify: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-    useEventListener: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    path: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>]>;
+    address: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+    showOnTrezor: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
+    chunkify: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
+    useEventListener: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
 }>;
 export interface Address {
     address: string;
@@ -73,16 +76,16 @@ export interface Address {
 }
 export type GetPublicKey = Static<typeof GetPublicKey>;
 export declare const GetPublicKey: import("@trezor/schema-utils").TObject<{
-    path: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>;
-    showOnTrezor: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-    suppressBackupWarning: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-    chunkify: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    path: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>]>;
+    showOnTrezor: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
+    suppressBackupWarning: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
+    chunkify: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
 }>;
 export type PublicKey = Static<typeof PublicKey>;
 export declare const PublicKey: import("@trezor/schema-utils").TObject<{
-    publicKey: import("@sinclair/typebox").TString;
-    path: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>;
-    serializedPath: import("@sinclair/typebox").TString;
+    publicKey: import("@trezor/schema-utils").TString;
+    path: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>;
+    serializedPath: import("@trezor/schema-utils").TString;
 }>;
 export {};
 //# sourceMappingURL=params.d.ts.map

package/lib/types/settings.d.ts

@@ -10,22 +10,16 @@ export interface ConnectSettingsPublic {
     manifest?: Manifest;
     connectSrc?: string;
     debug?: boolean;
-    hostLabel?: string;
-    hostIcon?: string;
     popup?: boolean;
     transportReconnect?: boolean;
-    webusb?: boolean;
     transports?: (Transport['name'] | Transport | (new (...args: any[]) => Transport))[];
     pendingTransportEvent?: boolean;
     lazyLoad?: boolean;
     interactionTimeout?: number;
     trustedHost: boolean;
-    coreMode?: 'auto' | 'popup' | 'iframe';
-    _extendWebextensionLifetime?: boolean;
-    _sessionsBackgroundUrl?: string;
-    deeplinkOpen?: (url: string) => void;
-    deeplinkCallbackUrl?: string;
+    _sessionsBackgroundUrl?: null | string;
     binFilesBaseUrl?: string;
+    enableFirmwareHashCheck?: boolean;
 }
 export interface ConnectSettingsInternal {
     origin?: string;
@@ -41,7 +35,19 @@ export interface ConnectSettingsInternal {
     proxy?: Proxy;
     sharedLogger?: boolean;
     useCoreInPopup?: boolean;
+}
+export interface ConnectSettingsWeb {
+    hostLabel?: string;
+    hostIcon?: string;
+    coreMode?: 'auto' | 'popup' | 'iframe' | 'deeplink';
+}
+export interface ConnectSettingsWebextension {
+    _extendWebextensionLifetime?: boolean;
+}
+export interface ConnectSettingsMobile {
     deeplinkUrl: string;
+    deeplinkOpen?: (url: string) => void;
+    deeplinkCallbackUrl?: string;
 }
-export type ConnectSettings = ConnectSettingsPublic & ConnectSettingsInternal;
+export type ConnectSettings = ConnectSettingsPublic & ConnectSettingsInternal & ConnectSettingsWeb & ConnectSettingsWebextension & ConnectSettingsMobile;
 //# sourceMappingURL=settings.d.ts.map

package/lib/types/utils.d.ts

@@ -12,4 +12,5 @@ export type MessageFactoryFn<Group, Event> = UnionToIntersection<Event extends {
     type: Event['type'];
     payload: undefined;
 } : never>;
+export declare const typedObjectKeys: <T extends Record<any, any>>(obj: T) => Array<keyof T>;
 //# sourceMappingURL=utils.d.ts.map

package/lib/types/utils.js

@@ -1,3 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.typedObjectKeys = void 0;
+const typedObjectKeys = (obj) => Object.keys(obj);
+exports.typedObjectKeys = typedObjectKeys;
 //# sourceMappingURL=utils.js.map

package/lib/utils/addressUtils.js

@@ -9,7 +9,7 @@ const isValidBase58Address = (address, network) => {
             return false;
         }
     }
-    catch (e) {
+    catch {
         return false;
     }
     return true;
@@ -21,7 +21,7 @@ const isValidBech32Address = (address, network) => {
             return false;
         }
     }
-    catch (e) {
+    catch {
         return false;
     }
     return true;

package/lib/utils/assetUtils.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryLocalAssetRequire = void 0;
+const utils_1 = require("@trezor/utils");
 const types_1 = require("../types");
-const isDeviceModel = (model) => {
-    return Object.values(types_1.DeviceModelInternal).includes(model);
-};
+const isDeviceModel = (model) => (0, utils_1.isArrayMember)(model, Object.values(types_1.DeviceModelInternal));
 const firmwareAssets = {
     [types_1.DeviceModelInternal.T1B1]: require('@trezor/connect-common/files/firmware/t1b1/releases.json'),
     [types_1.DeviceModelInternal.T2T1]: require('@trezor/connect-common/files/firmware/t2t1/releases.json'),
     [types_1.DeviceModelInternal.T2B1]: require('@trezor/connect-common/files/firmware/t2b1/releases.json'),
     [types_1.DeviceModelInternal.T3B1]: require('@trezor/connect-common/files/firmware/t3b1/releases.json'),
     [types_1.DeviceModelInternal.T3T1]: require('@trezor/connect-common/files/firmware/t3t1/releases.json'),
+    [types_1.DeviceModelInternal.T3W1]: require('@trezor/connect-common/files/firmware/t3w1/releases.json'),
 };
 const tryLocalAssetRequire = (url) => {
     const fileUrl = url.split('?')[0];

package/lib/utils/deviceFeaturesUtils.js

@@ -88,7 +88,7 @@ const getUnavailableCapabilities = (features, coins) => {
         if (info.shortcut === 'SOL' || info.shortcut === 'DSOL') {
             return !capabilities.includes('Capability_Solana');
         }
-        return !capabilities.includes(`Capability_${info.name}`);
+        return !(0, utils_1.isArrayMember)(`Capability_${info.name}`, capabilities);
     });
     unavailable.forEach(info => {
         list[info.shortcut.toLowerCase()] = 'no-capability';

package/lib/utils/uiPromiseManager.d.ts

@@ -1,10 +1,11 @@
 import { UiPromiseCreator, UiPromiseResponse } from '../events';
+import { DeviceUniquePath } from '../types/device';
 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;
+    disconnected: (devicePath: DeviceUniquePath) => boolean;
     get: <T extends UiPromiseResponse["type"]>(type: T) => Promise<Extract<import("../events").UiResponsePopupHandshake, {
         type: T;
     }> | Extract<import("../events").UiResponsePermission, {

package/lib/utils/uiPromiseManager.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createUiPromiseManager = void 0;
-const events_1 = require("../events");
 const utils_1 = require("@trezor/utils");
+const events_1 = require("../events");
 const createUiPromiseManager = (interactionTimeout) => {
     let _uiPromises = [];
     const exists = (type) => _uiPromises.some(p => p.id === type);
@@ -28,10 +28,10 @@ const createUiPromiseManager = (interactionTimeout) => {
         _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; });
+        const [toResolve, toKeep] = (0, utils_1.arrayPartition)(_uiPromises, (p) => { var _a; return ((_a = p.device) === null || _a === void 0 ? void 0 : _a.getUniquePath()) === 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; });
+        return !!toResolve.length || toKeep.some(p => { var _a; return ((_a = p.device) === null || _a === void 0 ? void 0 : _a.getUniquePath()) === devicePath; });
     };
     const get = (type) => {
         var _a;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trezor/connect",
-  "version": "9.4.3-beta.1",
+  "version": "9.4.3",
   "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.",
@@ -70,19 +70,19 @@
   },
   "dependencies": {
     "@babel/preset-typescript": "^7.24.7",
-    "@ethereumjs/common": "^4.3.0",
-    "@ethereumjs/tx": "^5.3.0",
+    "@ethereumjs/common": "^4.4.0",
+    "@ethereumjs/tx": "^5.4.0",
     "@fivebinaries/coin-selection": "2.2.1",
-    "@trezor/blockchain-link": "2.3.2-beta.1",
-    "@trezor/blockchain-link-types": "1.2.2-beta.1",
-    "@trezor/connect-analytics": "1.2.1",
-    "@trezor/connect-common": "0.2.3-beta.1",
-    "@trezor/protobuf": "1.2.3-beta.1",
+    "@trezor/blockchain-link": "2.3.2",
+    "@trezor/blockchain-link-types": "1.2.2",
+    "@trezor/connect-analytics": "1.2.2",
+    "@trezor/connect-common": "0.2.3",
+    "@trezor/protobuf": "1.2.3",
     "@trezor/protocol": "1.2.1",
-    "@trezor/schema-utils": "1.2.1",
-    "@trezor/transport": "1.3.3-beta.1",
-    "@trezor/utils": "9.2.2-beta.1",
-    "@trezor/utxo-lib": "2.2.1",
+    "@trezor/schema-utils": "1.2.2",
+    "@trezor/transport": "1.3.3",
+    "@trezor/utils": "9.2.2",
+    "@trezor/utxo-lib": "2.2.2",
     "blakejs": "^1.2.1",
     "bs58": "^6.0.0",
     "bs58check": "^4.0.0",
@@ -103,7 +103,7 @@
     "node-libs-browser": "^2.2.1",
     "ts-node": "^10.9.1",
     "tsx": "^4.16.3",
-    "webpack": "^5.94.0",
+    "webpack": "^5.96.1",
     "ws": "^8.18.0"
   },
   "peerDependencies": {

package/lib/api/checkFirmwareAuthenticity.d.ts

@@ -1,11 +0,0 @@
-import { AbstractMethod } from '../core/AbstractMethod';
-import { CheckFirmwareAuthenticityParams } from '../types/api/checkFirmwareAuthenticity';
-export default class CheckFirmwareAuthenticity extends AbstractMethod<'checkFirmwareAuthenticity', CheckFirmwareAuthenticityParams> {
-    init(): void;
-    run(): Promise<{
-        expectedFirmwareHash: string;
-        actualFirmwareHash: string;
-        valid: boolean;
-    }>;
-}
-//# sourceMappingURL=checkFirmwareAuthenticity.d.ts.map

package/lib/api/checkFirmwareAuthenticity.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const crypto_1 = require("crypto");
-const utils_1 = require("@trezor/utils");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const firmware_1 = require("./firmware");
-const firmwareInfo_1 = require("../data/firmwareInfo");
-const constants_1 = require("../constants");
-const types_1 = require("../types");
-const paramsValidator_1 = require("./common/paramsValidator");
-class CheckFirmwareAuthenticity extends AbstractMethod_1.AbstractMethod {
-    init() {
-        this.useEmptyPassphrase = true;
-        this.requiredPermissions = ['management'];
-        this.useDeviceState = false;
-        const { payload } = this;
-        (0, paramsValidator_1.validateParams)(payload, [{ name: 'baseUrl', type: 'string' }]);
-        this.params = { baseUrl: payload.baseUrl };
-    }
-    async run() {
-        var _a, _b;
-        const { device } = this;
-        if (!device.firmwareRelease) {
-            throw constants_1.ERRORS.TypedError('Runtime', 'device.firmwareRelease is not set');
-        }
-        const btcOnly = device.firmwareType === types_1.FirmwareType.BitcoinOnly;
-        try {
-            const version = device.getVersion();
-            const release = (0, firmwareInfo_1.getReleases)((_a = device.features) === null || _a === void 0 ? void 0 : _a.internal_model).find(r => version &&
-                utils_1.versionUtils.isVersionArray(version) &&
-                utils_1.versionUtils.isEqual(r.version, version));
-            if (!release) {
-                throw constants_1.ERRORS.TypedError('Runtime', 'no firmware found for this device');
-            }
-            const fw = await (0, firmware_1.getBinary)({
-                baseUrl: (_b = this.params.baseUrl) !== null && _b !== void 0 ? _b : 'https://data.trezor.io',
-                release,
-                btcOnly,
-            });
-            if (!fw) {
-                throw constants_1.ERRORS.TypedError('Runtime', 'checkFirmwareAuthenticity: firmware binary not found');
-            }
-            const { hash: expectedFirmwareHash, challenge } = (0, firmware_1.calculateFirmwareHash)(device.features.major_version, (0, firmware_1.stripFwHeaders)(fw), (0, crypto_1.randomBytes)(32));
-            const result = await this.device
-                .getCommands()
-                .typedCall('GetFirmwareHash', 'FirmwareHash', {
-                challenge,
-            });
-            const { message } = result;
-            const { hash: actualFirmwareHash } = message;
-            return {
-                expectedFirmwareHash,
-                actualFirmwareHash,
-                valid: actualFirmwareHash === expectedFirmwareHash,
-            };
-        }
-        catch (e) {
-            throw constants_1.ERRORS.TypedError('Runtime', `${e}`);
-        }
-    }
-}
-exports.default = CheckFirmwareAuthenticity;
-//# sourceMappingURL=checkFirmwareAuthenticity.js.map

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

@@ -1,11 +0,0 @@
-import type { Response, CommonParams } from '../params';
-export interface CheckFirmwareAuthenticityResponse {
-    expectedFirmwareHash: string;
-    actualFirmwareHash: string;
-    valid: boolean;
-}
-export type CheckFirmwareAuthenticityParams = CommonParams & {
-    baseUrl?: string;
-};
-export declare function checkFirmwareAuthenticity(params: CheckFirmwareAuthenticityParams): Response<CheckFirmwareAuthenticityResponse>;
-//# sourceMappingURL=checkFirmwareAuthenticity.d.ts.map