@trezor/connect 9.0.0-beta.1

package/lib/utils/browserUtils.d.ts

@@ -0,0 +1,21 @@
+export declare type BrowserState = {
+    name: string;
+    osname: string;
+    supported: boolean;
+    outdated: boolean;
+    mobile: boolean;
+};
+declare type SupportedBrowser = {
+    version: number;
+    download: string;
+    update: string;
+};
+export declare const getBrowserState: (supportedBrowsers: {
+    [key: string]: SupportedBrowser;
+}) => BrowserState;
+export declare const getOS: () => string;
+export declare const getSuggestedPlatform: () => string | undefined;
+export declare const suggestBridgeInstaller: () => import("..").BridgeInfo;
+export declare const suggestUdevInstaller: () => import("..").UdevInfo;
+export {};
+//# sourceMappingURL=browserUtils.d.ts.map

package/lib/utils/browserUtils.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suggestUdevInstaller = exports.suggestBridgeInstaller = exports.getSuggestedPlatform = exports.getOS = exports.getBrowserState = void 0;
+const tslib_1 = require("tslib");
+const bowser_1 = (0, tslib_1.__importDefault)(require("bowser"));
+const transportInfo_1 = require("../data/transportInfo");
+const udevInfo_1 = require("../data/udevInfo");
+const DEFAULT_STATE = {
+    name: 'unknown',
+    osname: 'unknown',
+    supported: false,
+    outdated: false,
+    mobile: false,
+};
+const getBrowserState = (supportedBrowsers) => {
+    if (typeof window === 'undefined' || !navigator || !navigator.userAgent)
+        return DEFAULT_STATE;
+    const { browser, os, platform } = bowser_1.default.parse(navigator.userAgent);
+    const mobile = platform.type === 'mobile';
+    let supported = browser.name ? supportedBrowsers[browser.name.toLowerCase()] : null;
+    let outdated = false;
+    if (mobile && typeof navigator.usb === 'undefined') {
+        supported = null;
+    }
+    if (supported) {
+        outdated = supported.version > parseInt(browser.version, 10);
+        if (outdated) {
+            supported = null;
+        }
+    }
+    return {
+        name: `${browser.name}: ${browser.version}; ${os.name}: ${os.version};`,
+        osname: os.name,
+        mobile,
+        supported: !!supported,
+        outdated,
+    };
+};
+exports.getBrowserState = getBrowserState;
+const getOS = () => {
+    if (typeof window === 'undefined' || !navigator || !navigator.userAgent)
+        return 'unknown';
+    const { os } = bowser_1.default.parse(navigator.userAgent);
+    return os.name ? os.name.toLowerCase() : 'unknown';
+};
+exports.getOS = getOS;
+const getSuggestedPlatform = () => {
+    if (typeof window === 'undefined' || !navigator || !navigator.userAgent)
+        return;
+    const agent = navigator.userAgent;
+    const { os } = bowser_1.default.parse(agent);
+    const name = os.name ? os.name.toLowerCase() : null;
+    switch (name) {
+        case 'linux': {
+            const isRpm = agent.match(/CentOS|Fedora|Mandriva|Mageia|Red Hat|Scientific|SUSE/)
+                ? 'rpm'
+                : 'deb';
+            const is64x = agent.match(/Linux i[3456]86/) ? '32' : '64';
+            return `${isRpm}${is64x}`;
+        }
+        case 'macos':
+            return 'mac';
+        case 'windows': {
+            const arch = agent.match(/(Win64|WOW64)/) ? '64' : '32';
+            return `win${arch}`;
+        }
+        default:
+            break;
+    }
+};
+exports.getSuggestedPlatform = getSuggestedPlatform;
+const suggestBridgeInstaller = () => {
+    const info = (0, transportInfo_1.getBridgeInfo)();
+    if (!info.packages.find(p => p.preferred)) {
+        const platform = (0, exports.getSuggestedPlatform)();
+        if (platform) {
+            info.packages = info.packages.map(p => ({
+                ...p,
+                preferred: p.platform.indexOf(platform) >= 0,
+            }));
+        }
+    }
+    return info;
+};
+exports.suggestBridgeInstaller = suggestBridgeInstaller;
+const suggestUdevInstaller = () => {
+    const info = (0, udevInfo_1.getUdevInfo)();
+    if (!info.packages.find(p => p.preferred)) {
+        const platform = (0, exports.getSuggestedPlatform)();
+        if (platform) {
+            info.packages = info.packages.map(p => ({
+                ...p,
+                preferred: p.platform.indexOf(platform) >= 0,
+            }));
+        }
+    }
+    return info;
+};
+exports.suggestUdevInstaller = suggestUdevInstaller;
+//# sourceMappingURL=browserUtils.js.map

package/lib/utils/bufferUtils.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export declare const reverseBuffer: (buf: Buffer) => Buffer;
+//# sourceMappingURL=bufferUtils.d.ts.map

package/lib/utils/bufferUtils.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reverseBuffer = void 0;
+const reverseBuffer = (buf) => {
+    const copy = Buffer.alloc(buf.length);
+    buf.copy(copy);
+    [].reverse.call(copy);
+    return copy;
+};
+exports.reverseBuffer = reverseBuffer;
+//# sourceMappingURL=bufferUtils.js.map

package/lib/utils/debug.d.ts

@@ -0,0 +1,24 @@
+declare type LogMessage = {
+    level: string;
+    prefix: string;
+    message: any[];
+    timestamp: number;
+};
+declare class Log {
+    prefix: string;
+    enabled: boolean;
+    css: string;
+    messages: LogMessage[];
+    constructor(prefix: string, enabled: boolean);
+    addMessage(level: string, prefix: string, ...args: any[]): void;
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    debug(...args: any[]): void;
+}
+export declare const initLog: (prefix: string, enabled?: boolean | undefined) => Log;
+export declare const enableLog: (enabled?: boolean | undefined) => void;
+export declare const enableLogByPrefix: (prefix: string, enabled: boolean) => void;
+export declare const getLog: () => LogMessage[];
+export {};
+//# sourceMappingURL=debug.d.ts.map

package/lib/utils/debug.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLog = exports.enableLogByPrefix = exports.enableLog = exports.initLog = void 0;
+const colors = {
+    '@trezor/connect': 'color: #f4a742; background: #000;',
+    IFrame: 'color: #f4a742; background: #000;',
+    Core: 'color: #f4a742; background: #000;',
+    DescriptorStream: 'color: #77ab59; background: #000;',
+    DeviceList: 'color: #77ab59; background: #000;',
+    Device: 'color: #bada55; background: #000;',
+    DeviceCommands: 'color: #bada55; background: #000;',
+};
+const MAX_ENTRIES = 100;
+class Log {
+    constructor(prefix, enabled) {
+        this.prefix = prefix;
+        this.enabled = enabled;
+        this.messages = [];
+        this.css = typeof window !== 'undefined' && colors[prefix] ? colors[prefix] : '';
+    }
+    addMessage(level, prefix, ...args) {
+        this.messages.push({
+            level,
+            prefix,
+            message: args,
+            timestamp: new Date().getTime(),
+        });
+        if (this.messages.length > MAX_ENTRIES) {
+            this.messages.shift();
+        }
+    }
+    log(...args) {
+        this.addMessage('log', this.prefix, ...args);
+        if (this.enabled) {
+            console.log(this.prefix, ...args);
+        }
+    }
+    error(...args) {
+        this.addMessage('error', this.prefix, ...args);
+        if (this.enabled) {
+            console.error(this.prefix, ...args);
+        }
+    }
+    warn(...args) {
+        this.addMessage('warn', this.prefix, ...args);
+        if (this.enabled) {
+            console.warn(this.prefix, ...args);
+        }
+    }
+    debug(...args) {
+        this.addMessage('debug', this.prefix, ...args);
+        if (this.enabled) {
+            if (this.css) {
+                console.log(`%c${this.prefix}`, this.css, ...args);
+            }
+            else {
+                console.log(this.prefix, ...args);
+            }
+        }
+    }
+}
+const _logs = {};
+const initLog = (prefix, enabled) => {
+    const instance = new Log(prefix, !!enabled);
+    _logs[prefix] = instance;
+    return instance;
+};
+exports.initLog = initLog;
+const enableLog = (enabled) => {
+    Object.keys(_logs).forEach(key => {
+        _logs[key].enabled = !!enabled;
+    });
+};
+exports.enableLog = enableLog;
+const enableLogByPrefix = (prefix, enabled) => {
+    if (_logs[prefix]) {
+        _logs[prefix].enabled = enabled;
+    }
+};
+exports.enableLogByPrefix = enableLogByPrefix;
+const getLog = () => {
+    let logs = [];
+    Object.keys(_logs).forEach(key => {
+        logs = logs.concat(_logs[key].messages);
+    });
+    logs.sort((a, b) => a.timestamp - b.timestamp);
+    return logs;
+};
+exports.getLog = getLog;
+//# sourceMappingURL=debug.js.map

package/lib/utils/deferred.d.ts

@@ -0,0 +1,18 @@
+export declare type Deferred<T, I = any, D = any> = {
+    id?: I;
+    data?: D;
+    promise: Promise<T>;
+    resolve: (t: T) => void;
+    reject: (e: Error) => void;
+};
+export declare type AsyncDeferred<T> = {
+    promise: Promise<T>;
+    resolve: (t: T) => void;
+    reject: (e: Error) => void;
+    run: (...args: any[]) => any;
+};
+export declare function create<T, I = any, D = any>(arg?: I, data?: D): Deferred<T, I, D>;
+export declare function createAsync<T>(innerFn: (...args: any[]) => any): AsyncDeferred<T>;
+export declare function resolveTimeoutPromise<T>(delay: number, result: T): Promise<T>;
+export declare const rejectTimeoutPromise: (delay: number, error: Error) => Promise<any>;
+//# sourceMappingURL=deferred.d.ts.map

package/lib/utils/deferred.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rejectTimeoutPromise = exports.resolveTimeoutPromise = exports.createAsync = exports.create = void 0;
+function create(arg, data) {
+    let localResolve = (_t) => { };
+    let localReject = (_e) => { };
+    let id;
+    const promise = new Promise(async (resolve, reject) => {
+        localResolve = resolve;
+        localReject = reject;
+        if (typeof arg === 'function') {
+            try {
+                await arg();
+            }
+            catch (error) {
+                reject(error);
+            }
+        }
+        if (typeof arg === 'string')
+            id = arg;
+    });
+    return {
+        id,
+        data,
+        resolve: localResolve,
+        reject: localReject,
+        promise,
+    };
+}
+exports.create = create;
+function createAsync(innerFn) {
+    let localResolve = (_t) => { };
+    let localReject = _e => { };
+    const promise = new Promise((resolve, reject) => {
+        localResolve = resolve;
+        localReject = reject;
+    });
+    const inner = async () => {
+        await innerFn();
+    };
+    return {
+        resolve: localResolve,
+        reject: localReject,
+        promise,
+        run: () => {
+            inner();
+            return promise;
+        },
+    };
+}
+exports.createAsync = createAsync;
+function resolveTimeoutPromise(delay, result) {
+    return new Promise(resolve => {
+        setTimeout(() => {
+            resolve(result);
+        }, delay);
+    });
+}
+exports.resolveTimeoutPromise = resolveTimeoutPromise;
+const rejectTimeoutPromise = (delay, error) => new Promise((_resolve, reject) => {
+    setTimeout(() => {
+        reject(error);
+    }, delay);
+});
+exports.rejectTimeoutPromise = rejectTimeoutPromise;
+//# sourceMappingURL=deferred.js.map

package/lib/utils/deviceFeaturesUtils.d.ts

@@ -0,0 +1,6 @@
+import { PROTO } from '../constants';
+import type { Features, CoinInfo, UnavailableCapabilities } from '../types';
+export declare const parseCapabilities: (features?: PROTO.Features | undefined) => PROTO.Capability[];
+export declare const getUnavailableCapabilities: (features: Features, coins: CoinInfo[]) => UnavailableCapabilities;
+export declare const parseRevision: (features: Features) => string | null;
+//# sourceMappingURL=deviceFeaturesUtils.d.ts.map

package/lib/utils/deviceFeaturesUtils.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRevision = exports.getUnavailableCapabilities = exports.parseCapabilities = void 0;
+const versionUtils_1 = require("./versionUtils");
+const config_1 = require("../data/config");
+const DEFAULT_CAPABILITIES_T1 = [
+    'Capability_Bitcoin',
+    'Capability_Bitcoin_like',
+    'Capability_Crypto',
+    'Capability_Ethereum',
+    'Capability_NEM',
+    'Capability_Stellar',
+    'Capability_U2F',
+];
+const DEFAULT_CAPABILITIES_TT = [
+    'Capability_Bitcoin',
+    'Capability_Bitcoin_like',
+    'Capability_Binance',
+    'Capability_Cardano',
+    'Capability_Crypto',
+    'Capability_EOS',
+    'Capability_Ethereum',
+    'Capability_Monero',
+    'Capability_NEM',
+    'Capability_Ripple',
+    'Capability_Stellar',
+    'Capability_Tezos',
+    'Capability_U2F',
+];
+const parseCapabilities = (features) => {
+    if (!features || features.firmware_present === false)
+        return [];
+    if (!features.capabilities || !features.capabilities.length) {
+        return features.major_version === 1 ? DEFAULT_CAPABILITIES_T1 : DEFAULT_CAPABILITIES_TT;
+    }
+    return features.capabilities;
+};
+exports.parseCapabilities = parseCapabilities;
+const getUnavailableCapabilities = (features, coins) => {
+    const { capabilities } = features;
+    const list = {};
+    if (!capabilities)
+        return list;
+    const fw = [features.major_version, features.minor_version, features.patch_version];
+    const key = `trezor${features.major_version}`;
+    const supported = coins.filter(info => {
+        if (!info.support || typeof info.support[key] !== 'string') {
+            list[info.shortcut.toLowerCase()] = 'no-support';
+            return false;
+        }
+        return true;
+    });
+    const unavailable = supported.filter(info => {
+        if (info.type === 'bitcoin') {
+            if (info.name === 'Bitcoin' || info.name === 'Testnet') {
+                return !capabilities.includes('Capability_Bitcoin');
+            }
+            return !capabilities.includes('Capability_Bitcoin_like');
+        }
+        if (info.type === 'ethereum') {
+            return !capabilities.includes('Capability_Ethereum');
+        }
+        if (info.type === 'nem') {
+            return !capabilities.includes('Capability_NEM');
+        }
+        if (info.shortcut === 'BNB')
+            return !capabilities.includes('Capability_Binance');
+        if (info.shortcut === 'ADA' || info.shortcut === 'tADA')
+            return !capabilities.includes('Capability_Cardano');
+        if (info.shortcut === 'XRP' || info.shortcut === 'tXRP')
+            return !capabilities.includes('Capability_Ripple');
+        return !capabilities.includes(`Capability_${info.name}`);
+    });
+    unavailable.forEach(info => {
+        list[info.shortcut.toLowerCase()] = 'no-capability';
+    });
+    supported
+        .filter(info => !unavailable.includes(info))
+        .forEach(info => {
+        if ((0, versionUtils_1.versionCompare)(info.support[key], fw) > 0) {
+            list[info.shortcut.toLowerCase()] = 'update-required';
+            unavailable.push(info);
+        }
+    });
+    config_1.config.supportedFirmware.forEach(s => {
+        if (!s.capabilities)
+            return;
+        const min = s.min ? s.min[fw[0] - 1] : null;
+        const max = s.max ? s.max[fw[0] - 1] : null;
+        if (min && (min === '0' || (0, versionUtils_1.versionCompare)(min, fw) > 0)) {
+            const value = min === '0' ? 'no-support' : 'update-required';
+            s.capabilities.forEach(m => {
+                list[m] = value;
+            });
+        }
+        if (max && (0, versionUtils_1.versionCompare)(max, fw) < 0) {
+            s.capabilities.forEach(m => {
+                list[m] = 'trezor-connect-outdated';
+            });
+        }
+    });
+    return list;
+};
+exports.getUnavailableCapabilities = getUnavailableCapabilities;
+const parseRevision = (features) => {
+    const { revision } = features;
+    if (!revision)
+        return null;
+    if (/^(?=.*[a-f])([a-f0-9]*)$/gi.test(revision))
+        return revision;
+    const revisionUtf8 = Buffer.from(revision, 'hex').toString('utf-8');
+    return /^([a-f0-9])*$/gi.test(revisionUtf8) ? revisionUtf8 : revision;
+};
+exports.parseRevision = parseRevision;
+//# sourceMappingURL=deviceFeaturesUtils.js.map

package/lib/utils/ethereumUtils.d.ts

@@ -0,0 +1,3 @@
+import type { CoinInfo } from '../types';
+export declare const getNetworkLabel: (label: string, network?: CoinInfo | undefined) => string;
+//# sourceMappingURL=ethereumUtils.d.ts.map

package/lib/utils/ethereumUtils.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNetworkLabel = void 0;
+const getNetworkLabel = (label, network) => {
+    if (network) {
+        const name = network.name.toLowerCase().indexOf('testnet') >= 0 ? 'Testnet' : network.name;
+        return label.replace('#NETWORK', name);
+    }
+    return label.replace('#NETWORK', '');
+};
+exports.getNetworkLabel = getNetworkLabel;
+//# sourceMappingURL=ethereumUtils.js.map

package/lib/utils/firmwareUtils.d.ts

@@ -0,0 +1,7 @@
+import type { Features, StrictFeatures, FirmwareRelease, VersionArray } from '../types';
+export declare const isStrictFeatures: (extFeatures: Features) => extFeatures is StrictFeatures;
+export declare const isValidReleases: (extReleases: any) => extReleases is FirmwareRelease[];
+export declare const getScore: (device_id: string) => number;
+export declare const filterSafeListByBootloader: (releasesList: FirmwareRelease[], bootloaderVersion: VersionArray) => FirmwareRelease[];
+export declare const filterSafeListByFirmware: (releasesList: FirmwareRelease[], firmwareVersion: VersionArray) => FirmwareRelease[];
+//# sourceMappingURL=firmwareUtils.d.ts.map

package/lib/utils/firmwareUtils.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterSafeListByFirmware = exports.filterSafeListByBootloader = exports.getScore = exports.isValidReleases = exports.isStrictFeatures = void 0;
+const crypto_1 = require("crypto");
+const utils_1 = require("@trezor/utils");
+const isStrictFeatures = (extFeatures) => [1, 2].includes(extFeatures.major_version) &&
+    (extFeatures.firmware_present === false ||
+        extFeatures.bootloader_mode == null ||
+        extFeatures.bootloader_mode === true);
+exports.isStrictFeatures = isStrictFeatures;
+const isValidReleases = (extReleases) => Array.isArray(extReleases) &&
+    extReleases.every(release => release.version && release.min_firmware_version && release.min_bootloader_version);
+exports.isValidReleases = isValidReleases;
+const getScore = (device_id) => {
+    const hash = (0, crypto_1.createHash)('sha256');
+    hash.update(device_id);
+    const output = parseInt(hash.digest('hex'), 16) / 2 ** 256;
+    return Math.round(output * 100) / 100;
+};
+exports.getScore = getScore;
+const filterSafeListByBootloader = (releasesList, bootloaderVersion) => releasesList.filter(item => (!item.min_bootloader_version ||
+    utils_1.versionUtils.isNewerOrEqual(bootloaderVersion, item.min_bootloader_version)) &&
+    (!item.bootloader_version ||
+        utils_1.versionUtils.isNewerOrEqual(item.bootloader_version, bootloaderVersion)));
+exports.filterSafeListByBootloader = filterSafeListByBootloader;
+const filterSafeListByFirmware = (releasesList, firmwareVersion) => releasesList.filter(item => utils_1.versionUtils.isNewerOrEqual(firmwareVersion, item.min_firmware_version));
+exports.filterSafeListByFirmware = filterSafeListByFirmware;
+//# sourceMappingURL=firmwareUtils.js.map

package/lib/utils/formatUtils.d.ts

@@ -0,0 +1,8 @@
+import type { CoinInfo } from '../types';
+export declare const formatAmount: (n: string, coinInfo: CoinInfo) => string;
+export declare const formatTime: (n: number) => string;
+export declare const btckb2satoshib: (n: string) => string;
+export declare const hasHexPrefix: (str: string) => boolean;
+export declare const stripHexPrefix: (str: string) => string;
+export declare const messageToHex: (message: string) => string;
+//# sourceMappingURL=formatUtils.d.ts.map

package/lib/utils/formatUtils.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messageToHex = exports.stripHexPrefix = exports.hasHexPrefix = exports.btckb2satoshib = exports.formatTime = exports.formatAmount = void 0;
+const tslib_1 = require("tslib");
+const bignumber_js_1 = (0, tslib_1.__importDefault)(require("bignumber.js"));
+const formatAmount = (n, coinInfo) => `${new bignumber_js_1.default(n).div(10 ** coinInfo.decimals).toString(10)} ${coinInfo.shortcut}`;
+exports.formatAmount = formatAmount;
+const formatTime = (n) => {
+    if (!n || n <= 0)
+        return 'No time estimate';
+    const hours = Math.floor(n / 60);
+    const minutes = n % 60;
+    let res = '';
+    if (hours !== 0) {
+        res += `${hours} hour`;
+        if (hours > 1) {
+            res += 's';
+        }
+        res += ' ';
+    }
+    if (minutes !== 0) {
+        res += `${minutes} minutes`;
+    }
+    return res;
+};
+exports.formatTime = formatTime;
+const btckb2satoshib = (n) => new bignumber_js_1.default(n).times(1e5).toFixed(0, bignumber_js_1.default.ROUND_HALF_UP);
+exports.btckb2satoshib = btckb2satoshib;
+const hasHexPrefix = (str) => str.slice(0, 2).toLowerCase() === '0x';
+exports.hasHexPrefix = hasHexPrefix;
+const stripHexPrefix = (str) => ((0, exports.hasHexPrefix)(str) ? str.slice(2) : str);
+exports.stripHexPrefix = stripHexPrefix;
+const isHexString = (value, length) => {
+    if (typeof value !== 'string' || !value.match(/^(0x|0X)?[0-9A-Fa-f]*$/)) {
+        return false;
+    }
+    if (length && value.length !== 2 + 2 * length) {
+        return false;
+    }
+    return true;
+};
+const messageToHex = (message) => {
+    let buffer;
+    if (isHexString(message)) {
+        let clean = (0, exports.stripHexPrefix)(message);
+        if (clean.length % 2 !== 0) {
+            clean = `0${clean}`;
+        }
+        buffer = Buffer.from(clean, 'hex');
+    }
+    else {
+        buffer = Buffer.from(message);
+    }
+    return buffer.toString('hex');
+};
+exports.messageToHex = messageToHex;
+//# sourceMappingURL=formatUtils.js.map

package/lib/utils/hdnodeUtils.d.ts

@@ -0,0 +1,8 @@
+import type { Network } from '@trezor/utxo-lib';
+import { PROTO } from '../constants';
+export declare const convertXpub: (xpub: string, originalNetwork?: Network | undefined, requestedNetwork?: Network | undefined) => string;
+export declare const convertBitcoinXpub: (xpub: string, network: Network) => string;
+export declare function xpubDerive<PK extends PROTO.PublicKey | PROTO.EthereumPublicKey>(xpub: PK, childXPub: PK, suffix: number, network?: Network, _requestedNetwork?: Network): PK;
+export declare const xpubToHDNodeType: (xpub: string, network: Network) => PROTO.HDNodeType;
+export declare const convertMultisigPubKey: <T extends PROTO.TxInputType | PROTO.TxOutputType>(network: Network, utxo: T) => T;
+//# sourceMappingURL=hdnodeUtils.d.ts.map