@trezor/connect 9.0.7 → 9.0.8

package/lib/api/ethereumSignMessage.js

@@ -6,6 +6,7 @@ const pathUtils_1 = require("../utils/pathUtils");
 const coinInfo_1 = require("../data/coinInfo");
 const ethereumUtils_1 = require("../utils/ethereumUtils");
 const formatUtils_1 = require("../utils/formatUtils");
+const ethereumDefinitions_1 = require("./ethereum/ethereumDefinitions");
 class EthereumSignMessage extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read', 'write'];
@@ -30,7 +31,19 @@ class EthereumSignMessage extends AbstractMethod_1.AbstractMethod {
     async run() {
         const cmd = this.device.getCommands();
         const { address_n, message } = this.params;
+        const network = (0, coinInfo_1.getEthereumNetwork)(address_n);
+        const slip44 = (0, pathUtils_1.getSlip44ByPath)(address_n);
+        const definitions = await (0, ethereumDefinitions_1.getEthereumDefinitions)({
+            chainId: network === null || network === void 0 ? void 0 : network.chainId,
+            slip44,
+        });
+        const definitionParams = {
+            ...(definitions.encoded_network && {
+                encoded_network: definitions.encoded_network,
+            }),
+        };
         const response = await cmd.typedCall('EthereumSignMessage', 'EthereumMessageSignature', {
+            ...definitionParams,
             address_n,
             message,
         });

package/lib/api/ethereumSignTransaction.js

@@ -8,6 +8,7 @@ const coinInfo_1 = require("../data/coinInfo");
 const ethereumUtils_1 = require("../utils/ethereumUtils");
 const formatUtils_1 = require("../utils/formatUtils");
 const helper = tslib_1.__importStar(require("./ethereum/ethereumSignTx"));
+const ethereumDefinitions_1 = require("./ethereum/ethereumDefinitions");
 const strip = value => {
     if (typeof value === 'string') {
         let stripped = (0, formatUtils_1.stripHexPrefix)(value);
@@ -71,11 +72,17 @@ class EthereumSignTransaction extends AbstractMethod_1.AbstractMethod {
             },
         };
     }
-    run() {
+    async run() {
         const { tx } = this.params;
+        const slip44 = (0, pathUtils_1.getSlip44ByPath)(this.params.path);
+        const definitions = await (0, ethereumDefinitions_1.getEthereumDefinitions)({
+            chainId: tx.chainId,
+            slip44,
+            contractAddress: tx.data ? tx.to : undefined,
+        });
         return tx.type === 'eip1559'
-            ? helper.ethereumSignTxEIP1559(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, tx.to, tx.value, tx.gasLimit, tx.maxFeePerGas, tx.maxPriorityFeePerGas, tx.nonce, tx.chainId, tx.data, tx.accessList)
-            : helper.ethereumSignTx(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, tx.to, tx.value, tx.gasLimit, tx.gasPrice, tx.nonce, tx.chainId, tx.data, tx.txType);
+            ? helper.ethereumSignTxEIP1559(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, tx.to, tx.value, tx.gasLimit, tx.maxFeePerGas, tx.maxPriorityFeePerGas, tx.nonce, tx.chainId, tx.data, tx.accessList, definitions)
+            : helper.ethereumSignTx(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, tx.to, tx.value, tx.gasLimit, tx.gasPrice, tx.nonce, tx.chainId, tx.data, tx.txType, definitions);
     }
 }
 exports.default = EthereumSignTransaction;

package/lib/api/ethereumSignTypedData.js

@@ -8,6 +8,7 @@ const ethereumUtils_1 = require("../utils/ethereumUtils");
 const constants_1 = require("../constants");
 const ethereumSignTypedData_1 = require("./ethereum/ethereumSignTypedData");
 const formatUtils_1 = require("../utils/formatUtils");
+const ethereumDefinitions_1 = require("./ethereum/ethereumDefinitions");
 class EthereumSignTypedData extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read', 'write'];
@@ -59,10 +60,22 @@ class EthereumSignTypedData extends AbstractMethod_1.AbstractMethod {
                 { name: 'message_hash', type: 'string' },
             ]);
             const { domain_separator_hash, message_hash } = this.params;
+            const network = (0, coinInfo_1.getEthereumNetwork)(address_n);
+            const slip44 = (0, pathUtils_1.getSlip44ByPath)(address_n);
+            const definitions = await (0, ethereumDefinitions_1.getEthereumDefinitions)({
+                chainId: network === null || network === void 0 ? void 0 : network.chainId,
+                slip44,
+            });
+            const definitionParams = {
+                ...(definitions.encoded_network && {
+                    encoded_network: definitions.encoded_network,
+                }),
+            };
             const response = await cmd.typedCall('EthereumSignTypedHash', 'EthereumTypedDataSignature', {
                 address_n,
                 domain_separator_hash: domain_separator_hash,
                 message_hash,
+                ...definitionParams,
             });
             const { address, signature } = response.message;
             return {

package/lib/api/firmware/getBinary.d.ts

@@ -1,20 +1,11 @@
 import { GetInfoProps } from '../../data/firmwareInfo';
+import { IntermediaryVersion } from '../../types';
 interface GetBinaryProps extends GetInfoProps {
     baseUrl: string;
     btcOnly?: boolean;
     version?: number[];
-    intermediary?: boolean;
+    intermediaryVersion?: IntermediaryVersion;
 }
-export declare const getBinary: ({ features, releases, baseUrl, version, btcOnly, intermediary, }: GetBinaryProps) => Promise<{
-    binary: any;
-} | {
-    binary: any;
-    changelog: import("../..").FirmwareRelease[] | null;
-    release: import("../..").FirmwareRelease;
-    isLatest: boolean;
-    latest: import("../..").FirmwareRelease;
-    isRequired: boolean | null;
-    isNewer: boolean | null;
-}>;
+export declare const getBinary: ({ features, releases, baseUrl, version, btcOnly, intermediaryVersion, }: GetBinaryProps) => any;
 export {};
 //# sourceMappingURL=getBinary.d.ts.map

package/lib/api/firmware/getBinary.js

@@ -5,13 +5,12 @@ const utils_1 = require("@trezor/utils");
 const assets_1 = require("../../utils/assets");
 const firmwareUtils_1 = require("../../utils/firmwareUtils");
 const firmwareInfo_1 = require("../../data/firmwareInfo");
-const getBinary = async ({ features, releases, baseUrl, version, btcOnly, intermediary = false, }) => {
+const getBinary = ({ features, releases, baseUrl, version, btcOnly, intermediaryVersion, }) => {
     if (!(0, firmwareUtils_1.isStrictFeatures)(features)) {
         throw new Error('Features of unexpected shape provided');
     }
-    if (intermediary && features.major_version !== 2) {
-        const fw = await (0, assets_1.httpRequest)(`${baseUrl}/firmware/1/trezor-inter-1.10.0.bin`, 'binary');
-        return { binary: fw };
+    if (intermediaryVersion) {
+        return (0, assets_1.httpRequest)(`${baseUrl}/firmware/1/trezor-inter-v${intermediaryVersion}.bin`, 'binary');
     }
     const infoByBootloader = (0, firmwareInfo_1.getInfo)({ features, releases });
     const releaseByFirmware = releases.find(r => version &&
@@ -26,11 +25,8 @@ const getBinary = async ({ features, releases, baseUrl, version, btcOnly, interm
     if (!utils_1.versionUtils.isEqual(releaseByFirmware.version, infoByBootloader.release.version)) {
         throw new Error('version provided as param does not match firmware version found by features in bootloader');
     }
-    const fw = await (0, assets_1.httpRequest)(`${baseUrl}/${btcOnly ? releaseByFirmware.url_bitcoinonly : releaseByFirmware.url}`, 'binary');
-    return {
-        ...infoByBootloader,
-        binary: fw,
-    };
+    const fwUrl = releaseByFirmware[btcOnly ? 'url_bitcoinonly' : 'url'];
+    return (0, assets_1.httpRequest)(`${baseUrl}/${fwUrl}`, 'binary');
 };
 exports.getBinary = getBinary;
 //# sourceMappingURL=getBinary.js.map

package/lib/api/firmwareUpdate.d.ts

@@ -1,10 +1,11 @@
 import { AbstractMethod } from '../core/AbstractMethod';
+import { IntermediaryVersion } from '../types';
 type Params = {
     binary?: ArrayBuffer;
     version?: number[];
     btcOnly?: boolean;
-    baseUrl?: string;
-    intermediary?: boolean;
+    baseUrl: string;
+    intermediaryVersion?: IntermediaryVersion;
 };
 export default class FirmwareUpdate extends AbstractMethod<'firmwareUpdate', Params> {
     init(): void;

package/lib/api/firmwareUpdate.js

@@ -22,14 +22,14 @@ class FirmwareUpdate extends AbstractMethod_1.AbstractMethod {
             { name: 'btcOnly', type: 'boolean' },
             { name: 'baseUrl', type: 'string' },
             { name: 'binary', type: 'array-buffer' },
-            { name: 'intermediary', type: 'boolean' },
+            { name: 'intermediaryVersion', type: 'number' },
         ]);
         if ('version' in payload) {
             this.params = {
                 version: payload.version,
                 btcOnly: payload.btcOnly,
                 baseUrl: payload.baseUrl || 'https://data.trezor.io',
-                intermediary: payload.intermediary,
+                intermediaryVersion: payload.intermediaryVersion,
             };
         }
         if ('binary' in payload) {
@@ -61,15 +61,14 @@ class FirmwareUpdate extends AbstractMethod_1.AbstractMethod {
                 binary = params.binary;
             }
             else {
-                const firmware = await (0, firmware_1.getBinary)({
+                binary = await (0, firmware_1.getBinary)({
                     features: device.features,
                     releases: (0, firmwareInfo_1.getReleases)(device.features.major_version),
                     version: params.version,
                     btcOnly: params.btcOnly,
                     baseUrl: params.baseUrl,
-                    intermediary: params.intermediary,
+                    intermediaryVersion: params.intermediaryVersion,
                 });
-                binary = firmware.binary;
             }
         }
         catch (err) {

package/lib/api/getAccountInfo.d.ts

@@ -20,18 +20,18 @@ export default class GetAccountInfo extends AbstractMethod<'getAccountInfo', Req
         balance: string;
         availableBalance: string;
         empty: boolean;
-        tokens?: import("packages/blockchain-link/lib/types/common").TokenInfo[] | undefined;
-        addresses?: import("packages/blockchain-link/lib/types/common").AccountAddresses | undefined;
+        tokens?: import("packages/blockchain-link-types/lib/common").TokenInfo[] | undefined;
+        addresses?: import("packages/blockchain-link-types/lib/common").AccountAddresses | undefined;
         history: {
             total: number;
             tokens?: number | undefined;
             unconfirmed: number;
-            transactions?: import("packages/blockchain-link/lib/types/common").Transaction[] | undefined;
+            transactions?: import("packages/blockchain-link-types/lib/common").Transaction[] | undefined;
             txids?: string[] | undefined;
         };
         misc?: {
             nonce?: string | undefined;
-            erc20Contract?: import("packages/blockchain-link/lib/types/common").TokenInfo | undefined;
+            erc20Contract?: import("packages/blockchain-link-types/lib/common").TokenInfo | undefined;
             sequence?: number | undefined;
             reserve?: string | undefined;
             rewards?: string | undefined;
@@ -59,18 +59,18 @@ export default class GetAccountInfo extends AbstractMethod<'getAccountInfo', Req
         balance: string;
         availableBalance: string;
         empty: boolean;
-        tokens?: import("packages/blockchain-link/lib/types/common").TokenInfo[] | undefined;
-        addresses?: import("packages/blockchain-link/lib/types/common").AccountAddresses | undefined;
+        tokens?: import("packages/blockchain-link-types/lib/common").TokenInfo[] | undefined;
+        addresses?: import("packages/blockchain-link-types/lib/common").AccountAddresses | undefined;
         history: {
             total: number;
             tokens?: number | undefined;
             unconfirmed: number;
-            transactions?: import("packages/blockchain-link/lib/types/common").Transaction[] | undefined;
+            transactions?: import("packages/blockchain-link-types/lib/common").Transaction[] | undefined;
             txids?: string[] | undefined;
         };
         misc?: {
             nonce?: string | undefined;
-            erc20Contract?: import("packages/blockchain-link/lib/types/common").TokenInfo | undefined;
+            erc20Contract?: import("packages/blockchain-link-types/lib/common").TokenInfo | undefined;
             sequence?: number | undefined;
             reserve?: string | undefined;
             rewards?: string | undefined;

package/lib/api/getAccountInfo.js

@@ -287,7 +287,7 @@ class GetAccountInfo extends AbstractMethod_1.AbstractMethod {
         discovery.stop();
         const account = discovery.accounts[uiResp.payload];
         if (!discovery.completed) {
-            await (0, promiseUtils_1.resolveAfter)(501);
+            await (0, promiseUtils_1.resolveAfter)(501).promise;
         }
         const info = await blockchain.getAccountInfo({
             descriptor: account.descriptor,

package/lib/api/setBusy.js

@@ -9,10 +9,7 @@ class SetBusy extends AbstractMethod_1.AbstractMethod {
         this.requiredPermissions = ['management'];
         const { payload } = this;
         (0, paramsValidator_1.validateParams)(payload, [{ name: 'expiry_ms', type: 'number' }]);
-        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, {
-            1: { min: '0', max: '0' },
-            2: { min: '2.5.3', max: '0' },
-        });
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, undefined, this.firmwareRange);
         this.params = {
             expiry_ms: payload.expiry_ms,
         };

package/lib/api/setProxy.js

@@ -15,7 +15,7 @@ class SetProxy extends AbstractMethod_1.AbstractMethod {
         const { proxy } = DataManager_1.DataManager.getSettings();
         const isChanged = proxy !== this.payload.proxy;
         if (isChanged) {
-            DataManager_1.DataManager.settings.proxy = this.payload.proxy;
+            DataManager_1.DataManager.getSettings().proxy = this.payload.proxy;
             await (0, BlockchainLink_1.reconnectAllBackends)();
         }
         return { message: 'Success' };

package/lib/api/signTransaction.d.ts

@@ -1,6 +1,6 @@
 import { AbstractMethod } from '../core/AbstractMethod';
 import { PROTO } from '../constants';
-import type { BitcoinNetworkInfo, AccountAddresses } from '../types';
+import type { BitcoinNetworkInfo, AccountAddresses, AccountUtxo } from '../types';
 import type { RefTransaction, TransactionOptions } from '../types/api/bitcoin';
 type Params = {
     inputs: PROTO.TxInputType[];
@@ -9,6 +9,7 @@ type Params = {
     coinjoinRequest?: PROTO.CoinJoinRequest;
     refTxs?: RefTransaction[];
     addresses?: AccountAddresses;
+    utxo?: AccountUtxo[];
     options: TransactionOptions;
     coinInfo: BitcoinNetworkInfo;
     push: boolean;

package/lib/api/signTransaction.js

@@ -66,6 +66,7 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
             paymentRequests: payload.paymentRequests || [],
             refTxs,
             addresses: payload.account ? payload.account.addresses : undefined,
+            utxo: payload.account ? payload.account.utxo : undefined,
             options: {
                 lock_time: payload.locktime,
                 timestamp: payload.timestamp,
@@ -143,15 +144,24 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
         if (!response.serializedTx) {
             return response;
         }
+        let bitcoinTx;
         if (params.options.decred_staking_ticket) {
             await (0, bitcoin_1.verifyTicketTx)(device.getCommands().getHDNode.bind(device.getCommands()), params.inputs, params.outputs, response.serializedTx, params.coinInfo);
         }
         else {
-            const bitcoinTx = await (0, bitcoin_1.verifyTx)(device.getCommands().getHDNode.bind(device.getCommands()), params.inputs, params.outputs, response.serializedTx, params.coinInfo, params.unlockPath);
+            bitcoinTx = await (0, bitcoin_1.verifyTx)(device.getCommands().getHDNode.bind(device.getCommands()), params.inputs, params.outputs, response.serializedTx, params.coinInfo, params.unlockPath);
             if (bitcoinTx.hasWitnesses()) {
-                response.witnesses = bitcoinTx.ins.map((_, i) => { var _a; return (_a = bitcoinTx.getWitness(i)) === null || _a === void 0 ? void 0 : _a.toString('hex'); });
+                response.witnesses = bitcoinTx.ins.map((_, i) => { var _a; return (_a = bitcoinTx === null || bitcoinTx === void 0 ? void 0 : bitcoinTx.getWitness(i)) === null || _a === void 0 ? void 0 : _a.toString('hex'); });
             }
         }
+        if (bitcoinTx && params.addresses && params.utxo) {
+            response.signedTransaction = (0, bitcoin_1.createPendingTransaction)(bitcoinTx, {
+                utxo: params.utxo,
+                addresses: params.addresses,
+                inputs: params.inputs,
+                outputs: params.outputs,
+            });
+        }
         if (params.push) {
             (0, BlockchainLink_1.isBackendSupported)(params.coinInfo);
             const blockchain = await (0, BlockchainLink_1.initBlockchain)(params.coinInfo, this.postMessage);

package/lib/api/unlockPath.js

@@ -7,10 +7,7 @@ class UnlockPath extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read'];
         this.skipFinalReload = true;
-        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, {
-            1: { min: '0', max: '0' },
-            2: { min: '2.5.3', max: '0' },
-        });
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, undefined, this.firmwareRange);
         const { payload } = this;
         (0, paramsValidator_1.validateParams)(payload, [
             { name: 'path', required: true },

package/lib/backend/Blockchain.d.ts

@@ -25,12 +25,15 @@ export declare class Blockchain {
     getTransactions(txs: string[]): Promise<import("@trezor/blockchain-link").TypedRawTransaction[]>;
     getCurrentFiatRates(params: {
         currencies?: string[];
+        token?: string;
     }): Promise<{
         ts: number;
         rates: import("@trezor/blockchain-link").FiatRates;
     }>;
     getFiatRatesForTimestamps(params: {
+        currencies?: string[];
         timestamps: number[];
+        token?: string;
     }): Promise<{
         tickers: {
             ts: number;

package/lib/core/AbstractMethod.d.ts

@@ -52,6 +52,7 @@ export declare abstract class AbstractMethod<Name extends CallMethodPayload['met
     checkPermissions(): void;
     savePermissions(temporary?: boolean): void;
     checkFirmwareRange(isUsingPopup?: boolean): Promise<"ui-device_firmware_old" | "ui-device_firmware_unsupported" | "ui-device_firmware_not_compatible" | "ui-device_firmware_not_installed" | undefined>;
+    isManagementRestricted(): boolean | undefined;
     abstract init(): void;
     abstract run(): Promise<MethodReturnType<Name>>;
     dispose(): void;

package/lib/core/AbstractMethod.js

@@ -6,6 +6,7 @@ const DataManager_1 = require("../data/DataManager");
 const constants_1 = require("../constants");
 const events_1 = require("../events");
 const versionUtils_1 = require("../utils/versionUtils");
+const urlUtils_1 = require("../utils/urlUtils");
 class AbstractMethod {
     constructor(message) {
         var _a, _b;
@@ -154,6 +155,14 @@ class AbstractMethod {
             }
         }
     }
+    isManagementRestricted() {
+        const { popup, origin } = DataManager_1.DataManager.getSettings();
+        if (popup && this.requiredPermissions.includes('management')) {
+            const host = (0, urlUtils_1.getHost)(origin);
+            const allowed = DataManager_1.DataManager.getConfig().management.find(item => item.origin === host || item.origin === origin);
+            return !allowed;
+        }
+    }
     dispose() { }
 }
 exports.AbstractMethod = AbstractMethod;

package/lib/core/index.js

@@ -21,6 +21,7 @@ let _uiPromises = [];
 const _callMethods = [];
 let _preferredDevice;
 let _interactionTimeout;
+let _deviceListInitTimeout;
 const _log = (0, debug_1.initLog)('Core');
 const postMessage = (message) => {
     if (message.event === events_2.RESPONSE_EVENT) {
@@ -196,9 +197,7 @@ const onCall = async (message) => {
     if (!_deviceList && !DataManager_1.DataManager.getSettings('transportReconnect')) {
         await (0, exports.initTransport)(DataManager_1.DataManager.getSettings());
     }
-    if (isUsingPopup &&
-        method.requiredPermissions.includes('management') &&
-        !DataManager_1.DataManager.isManagementAllowed()) {
+    if (method.isManagementRestricted()) {
         postMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
         postMessage((0, events_2.createResponseMessage)(responseID, false, {
             error: constants_1.ERRORS.TypedError('Method_NotAllowed'),
@@ -380,7 +379,7 @@ const onCall = async (message) => {
         const response = messageResponse;
         if (response) {
             if (method.name === 'rebootToBootloader' && response.success) {
-                await (0, promiseUtils_1.resolveAfter)(1000);
+                await (0, promiseUtils_1.resolveAfter)(1000).promise;
                 await device.run(() => Promise.resolve(), { skipFinalReload: true });
             }
             await device.cleanup();
@@ -564,8 +563,10 @@ const initDeviceList = async (settings) => {
             _deviceList = undefined;
             postMessage((0, events_2.createTransportMessage)(events_2.TRANSPORT.ERROR, { error }));
             if (settings.transportReconnect) {
-                await (0, promiseUtils_1.resolveAfter)(1000, null);
-                await initDeviceList(settings);
+                const { promise, timeout } = (0, promiseUtils_1.resolveAfter)(1000, null);
+                _deviceListInitTimeout = timeout;
+                await promise;
+                initDeviceList(settings);
             }
         });
         _deviceList.on(events_2.TRANSPORT.START, transportType => postMessage((0, events_2.createTransportMessage)(events_2.TRANSPORT.START, transportType)));
@@ -581,7 +582,9 @@ const initDeviceList = async (settings) => {
             throw error;
         }
         else {
-            await (0, promiseUtils_1.resolveAfter)(3000, null);
+            const { promise, timeout } = (0, promiseUtils_1.resolveAfter)(3000, null);
+            _deviceListInitTimeout = timeout;
+            await promise;
             await initDeviceList(settings);
         }
     }
@@ -592,6 +595,9 @@ class Core extends events_1.default {
     }
     async dispose() {
         (0, BlockchainLink_1.dispose)();
+        if (_deviceListInitTimeout) {
+            clearTimeout(_deviceListInitTimeout);
+        }
         this.removeAllListeners();
         if (_deviceList) {
             await _deviceList.dispose();

package/lib/data/DataManager.d.ts

@@ -1,29 +1,106 @@
-import { config } from './config';
 import type { ConnectSettings } from '../types';
 type AssetCollection = {
     [key: string]: JSON;
 };
 export declare class DataManager {
     static assets: AssetCollection;
-    static settings: ConnectSettings;
+    private static settings;
     private static messages;
     static load(settings: ConnectSettings, withAssets?: boolean): Promise<void>;
     static getProtobufMessages(): JSON;
-    static isWhitelisted(origin: string): {
-        origin: string;
-        priority: number;
-    } | undefined;
-    static isManagementAllowed(): {
-        origin: string;
-    } | undefined;
-    static getPriority(whitelist?: (typeof config)['whitelist'][0]): number;
-    static getHostLabel(origin: string): {
-        origin: string;
-        label: string;
-        icon: string;
-    } | undefined;
     static getSettings(key?: undefined): ConnectSettings;
     static getSettings<T extends keyof ConnectSettings>(key: T): ConnectSettings[T];
+    static getConfig(): {
+        webusb: {
+            vendorId: number;
+            productId: number;
+        }[];
+        whitelist: {
+            origin: string;
+            priority: number;
+        }[];
+        management: {
+            origin: string;
+        }[];
+        knownHosts: {
+            origin: string;
+            label: string;
+            icon: string;
+        }[];
+        onionDomains: {
+            'trezor.io': string;
+        };
+        assets: {
+            name: string;
+            url: string;
+        }[];
+        messages: string;
+        supportedBrowsers: {
+            chrome: {
+                version: number;
+                download: string;
+                update: string;
+            };
+            chromium: {
+                version: number;
+                download: string;
+                update: string;
+            };
+            electron: {
+                version: number;
+                download: string;
+                update: string;
+            };
+            firefox: {
+                version: number;
+                download: string;
+                update: string;
+            };
+        };
+        supportedFirmware: ({
+            coin: string[];
+            methods: string[];
+            min: string[];
+            max: undefined;
+            comment: string[];
+            capabilities?: undefined;
+        } | {
+            coin: string[];
+            min: string[];
+            comment: string[];
+            methods?: undefined;
+            max?: undefined;
+            capabilities?: undefined;
+        } | {
+            methods: string[];
+            min: string[];
+            comment: string[];
+            coin?: undefined;
+            max?: undefined;
+            capabilities?: undefined;
+        } | {
+            capabilities: string[];
+            min: string[];
+            comment: string[];
+            coin?: undefined;
+            methods?: undefined;
+            max?: undefined;
+        } | {
+            coin: string[];
+            methods: string[];
+            min: string[];
+            comment: string[];
+            max?: undefined;
+            capabilities?: undefined;
+        } | {
+            capabilities: string[];
+            methods: string[];
+            min: string[];
+            coin?: undefined;
+            max?: undefined;
+            comment?: undefined;
+        })[];
+    };
 }
 export {};
 //# sourceMappingURL=DataManager.d.ts.map

package/lib/data/DataManager.js

@@ -1,39 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataManager = void 0;
-const tslib_1 = require("tslib");
-const parse_uri_1 = tslib_1.__importDefault(require("parse-uri"));
 const assets_1 = require("../utils/assets");
-const connectSettings_1 = require("./connectSettings");
 const coinInfo_1 = require("./coinInfo");
 const firmwareInfo_1 = require("./firmwareInfo");
 const transportInfo_1 = require("./transportInfo");
 const config_1 = require("./config");
 class DataManager {
     static async load(settings, withAssets = true) {
-        var _a;
         const ts = settings.env === 'web' ? `?r=${settings.timestamp}` : '';
         this.settings = settings;
-        const isLocalhost = typeof window !== 'undefined' && window.location
-            ? window.location.hostname === 'localhost'
-            : true;
-        const whitelist = DataManager.isWhitelisted(this.settings.origin || '');
-        this.settings.trustedHost = (isLocalhost || !!whitelist) && !this.settings.popup;
-        if (!this.settings.trustedHost) {
-            this.settings.popup = true;
-        }
-        if (!this.settings.trustedHost && !whitelist) {
-            this.settings.debug = false;
-        }
-        this.settings.priority = DataManager.getPriority(whitelist);
-        const knownHost = DataManager.getHostLabel(this.settings.extension || this.settings.origin || '');
-        if (knownHost) {
-            this.settings.hostLabel = knownHost.label;
-            this.settings.hostIcon = knownHost.icon;
-        }
-        if (this.settings.popup && this.settings.env !== 'webextension') {
-            this.settings.transports = (_a = this.settings.transports) === null || _a === void 0 ? void 0 : _a.filter((transport) => transport !== 'WebUsbTransport');
-        }
         if (!withAssets)
             return;
         const assetPromises = config_1.config.assets.map(async (asset) => {
@@ -50,36 +26,6 @@ class DataManager {
     static getProtobufMessages() {
         return this.messages;
     }
-    static isWhitelisted(origin) {
-        const uri = (0, parse_uri_1.default)(origin);
-        if (uri && typeof uri.host === 'string') {
-            const parts = uri.host.split('.');
-            if (parts.length > 2) {
-                uri.host = parts.slice(parts.length - 2, parts.length).join('.');
-            }
-            return config_1.config.whitelist.find(item => item.origin === origin || item.origin === uri.host);
-        }
-    }
-    static isManagementAllowed() {
-        var _a;
-        const uri = (0, parse_uri_1.default)((_a = this.settings.origin) !== null && _a !== void 0 ? _a : '');
-        if (uri && typeof uri.host === 'string') {
-            const parts = uri.host.split('.');
-            if (parts.length > 2) {
-                uri.host = parts.slice(parts.length - 2, parts.length).join('.');
-            }
-            return config_1.config.management.find(item => item.origin === this.settings.origin || item.origin === uri.host);
-        }
-    }
-    static getPriority(whitelist) {
-        if (whitelist) {
-            return whitelist.priority;
-        }
-        return connectSettings_1.DEFAULT_PRIORITY;
-    }
-    static getHostLabel(origin) {
-        return config_1.config.knownHosts.find(host => host.origin === origin);
-    }
     static getSettings(key) {
         if (!this.settings)
             return null;
@@ -88,6 +34,9 @@ class DataManager {
         }
         return this.settings;
     }
+    static getConfig() {
+        return config_1.config;
+    }
 }
 exports.DataManager = DataManager;
 DataManager.assets = {};