@trezor/connect 9.0.0-beta.1

package/lib/data/DataManager.d.ts

@@ -0,0 +1,31 @@
+import { config } from './config';
+import type { ConnectSettings } from '../types';
+declare type AssetCollection = {
+    [key: string]: JSON;
+};
+export declare class DataManager {
+    static assets: AssetCollection;
+    static settings: ConnectSettings;
+    static messages: {
+        [key: string]: JSON;
+    };
+    static load(settings: ConnectSettings, withAssets?: boolean): Promise<void>;
+    static getProtobufMessages(_version?: number[]): 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];
+}
+export {};
+//# sourceMappingURL=DataManager.d.ts.map

package/lib/data/DataManager.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataManager = void 0;
+const tslib_1 = require("tslib");
+const parse_uri_1 = (0, 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) {
+        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.webusb && this.settings.env !== 'webextension') {
+            this.settings.webusb = false;
+        }
+        if (!withAssets)
+            return;
+        const assetPromises = config_1.config.assets.map(async (asset) => {
+            const json = await (0, assets_1.httpRequest)(`${asset.url}${ts}`, 'json');
+            this.assets[asset.name] = json;
+        });
+        await Promise.all(assetPromises);
+        const protobufPromises = config_1.config.messages.map(async (protobuf) => {
+            const json = await (0, assets_1.httpRequest)(`${protobuf.json}${ts}`, 'json');
+            this.messages[protobuf.name] = json;
+        });
+        await Promise.all(protobufPromises);
+        (0, transportInfo_1.parseBridgeJSON)(this.assets.bridge);
+        (0, coinInfo_1.parseCoinsJson)(this.assets.coins);
+        (0, firmwareInfo_1.parseFirmware)(this.assets['firmware-t1'], 1);
+        (0, firmwareInfo_1.parseFirmware)(this.assets['firmware-t2'], 2);
+    }
+    static getProtobufMessages(_version) {
+        return this.messages.default;
+    }
+    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;
+        if (typeof key === 'string') {
+            return this.settings[key];
+        }
+        return this.settings;
+    }
+}
+exports.DataManager = DataManager;
+DataManager.assets = {};
+DataManager.messages = {};
+//# sourceMappingURL=DataManager.js.map

package/lib/data/coinInfo.d.ts

@@ -0,0 +1,37 @@
+import type { CoinInfo, BitcoinNetworkInfo, EthereumNetworkInfo, MiscNetworkInfo } from '../types/coinInfo';
+export declare function cloneCoinInfo<T>(info: T): T;
+export declare const getBitcoinNetwork: (pathOrName: number[] | string) => BitcoinNetworkInfo | undefined;
+export declare const getEthereumNetwork: (pathOrName: number[] | string) => EthereumNetworkInfo | undefined;
+export declare const getMiscNetwork: (pathOrName: number[] | string) => MiscNetworkInfo | undefined;
+export declare const getSegwitNetwork: (coin: BitcoinNetworkInfo) => {
+    bip32: {
+        public: number;
+        private: number;
+    };
+    messagePrefix: string;
+    bech32: string;
+    pubKeyHash: number;
+    scriptHash: number;
+    wif: number;
+    forkId?: number | undefined;
+} | null;
+export declare const getBech32Network: (coin: BitcoinNetworkInfo) => {
+    bip32: {
+        public: number;
+        private: number;
+    };
+    messagePrefix: string;
+    bech32: string;
+    pubKeyHash: number;
+    scriptHash: number;
+    wif: number;
+    forkId?: number | undefined;
+} | null;
+export declare const fixCoinInfoNetwork: (ci: BitcoinNetworkInfo, path: number[]) => BitcoinNetworkInfo;
+export declare const getCoinInfoByHash: (hash: string, networkInfo: any) => BitcoinNetworkInfo;
+export declare const getCoinInfo: (currency: string) => BitcoinNetworkInfo | EthereumNetworkInfo | MiscNetworkInfo | undefined;
+export declare const getCoinName: (path: number[]) => string;
+export declare const parseCoinsJson: (json: any) => void;
+export declare const getUniqueNetworks: (networks: (CoinInfo | undefined)[]) => CoinInfo[];
+export declare const getAllNetworks: () => (BitcoinNetworkInfo | EthereumNetworkInfo | MiscNetworkInfo)[];
+//# sourceMappingURL=coinInfo.d.ts.map

package/lib/data/coinInfo.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllNetworks = exports.getUniqueNetworks = exports.parseCoinsJson = exports.getCoinName = exports.getCoinInfo = exports.getCoinInfoByHash = exports.fixCoinInfoNetwork = exports.getBech32Network = exports.getSegwitNetwork = exports.getMiscNetwork = exports.getEthereumNetwork = exports.getBitcoinNetwork = exports.cloneCoinInfo = void 0;
+const constants_1 = require("../constants");
+const pathUtils_1 = require("../utils/pathUtils");
+const bitcoinNetworks = [];
+const ethereumNetworks = [];
+const miscNetworks = [];
+function cloneCoinInfo(info) {
+    const jsonString = JSON.stringify(info);
+    if (jsonString === undefined) {
+        return info;
+    }
+    return JSON.parse(jsonString);
+}
+exports.cloneCoinInfo = cloneCoinInfo;
+const getBitcoinNetwork = (pathOrName) => {
+    const networks = cloneCoinInfo(bitcoinNetworks);
+    if (typeof pathOrName === 'string') {
+        const name = pathOrName.toLowerCase();
+        return networks.find(n => n.name.toLowerCase() === name ||
+            n.shortcut.toLowerCase() === name ||
+            n.label.toLowerCase() === name);
+    }
+    const slip44 = (0, pathUtils_1.fromHardened)(pathOrName[1]);
+    return networks.find(n => n.slip44 === slip44);
+};
+exports.getBitcoinNetwork = getBitcoinNetwork;
+const getEthereumNetwork = (pathOrName) => {
+    const networks = cloneCoinInfo(ethereumNetworks);
+    if (typeof pathOrName === 'string') {
+        const name = pathOrName.toLowerCase();
+        return networks.find(n => n.name.toLowerCase() === name || n.shortcut.toLowerCase() === name);
+    }
+    const slip44 = (0, pathUtils_1.fromHardened)(pathOrName[1]);
+    return networks.find(n => n.slip44 === slip44);
+};
+exports.getEthereumNetwork = getEthereumNetwork;
+const getMiscNetwork = (pathOrName) => {
+    const networks = cloneCoinInfo(miscNetworks);
+    if (typeof pathOrName === 'string') {
+        const name = pathOrName.toLowerCase();
+        return networks.find(n => n.name.toLowerCase() === name || n.shortcut.toLowerCase() === name);
+    }
+    const slip44 = (0, pathUtils_1.fromHardened)(pathOrName[1]);
+    return networks.find(n => n.slip44 === slip44);
+};
+exports.getMiscNetwork = getMiscNetwork;
+const getSegwitNetwork = (coin) => {
+    if (coin.segwit && typeof coin.xPubMagicSegwit === 'number') {
+        return {
+            ...coin.network,
+            bip32: {
+                ...coin.network.bip32,
+                public: coin.xPubMagicSegwit,
+            },
+        };
+    }
+    return null;
+};
+exports.getSegwitNetwork = getSegwitNetwork;
+const getBech32Network = (coin) => {
+    if (coin.segwit && typeof coin.xPubMagicSegwitNative === 'number') {
+        return {
+            ...coin.network,
+            bip32: {
+                ...coin.network.bip32,
+                public: coin.xPubMagicSegwitNative,
+            },
+        };
+    }
+    return null;
+};
+exports.getBech32Network = getBech32Network;
+const fixCoinInfoNetwork = (ci, path) => {
+    const coinInfo = cloneCoinInfo(ci);
+    if (path[0] === (0, pathUtils_1.toHardened)(84)) {
+        const bech32Network = (0, exports.getBech32Network)(coinInfo);
+        if (bech32Network) {
+            coinInfo.network = bech32Network;
+        }
+    }
+    else if (path[0] === (0, pathUtils_1.toHardened)(49)) {
+        const segwitNetwork = (0, exports.getSegwitNetwork)(coinInfo);
+        if (segwitNetwork) {
+            coinInfo.network = segwitNetwork;
+        }
+    }
+    else {
+        coinInfo.segwit = false;
+    }
+    return coinInfo;
+};
+exports.fixCoinInfoNetwork = fixCoinInfoNetwork;
+const detectBtcVersion = (data) => {
+    if (data.subversion == null) {
+        return 'btc';
+    }
+    if (data.subversion.startsWith('/Bitcoin ABC')) {
+        return 'bch';
+    }
+    if (data.subversion.startsWith('/Bitcoin Cash')) {
+        return 'bch';
+    }
+    if (data.subversion.startsWith('/Bitcoin Gold')) {
+        return 'btg';
+    }
+    return 'btc';
+};
+const getCoinInfoByHash = (hash, networkInfo) => {
+    const networks = cloneCoinInfo(bitcoinNetworks);
+    const result = networks.find(info => hash.toLowerCase() === info.hashGenesisBlock.toLowerCase());
+    if (!result) {
+        throw constants_1.ERRORS.TypedError('Method_UnknownCoin', `Coin info not found for hash: ${hash} ${networkInfo.hashGenesisBlock}`);
+    }
+    if (result.isBitcoin) {
+        const btcVersion = detectBtcVersion(networkInfo);
+        let fork;
+        if (btcVersion === 'bch') {
+            fork = networks.find(info => info.name === 'Bcash');
+        }
+        else if (btcVersion === 'btg') {
+            fork = networks.find(info => info.name === 'Bgold');
+        }
+        if (fork) {
+            return fork;
+        }
+        throw constants_1.ERRORS.TypedError('Method_UnknownCoin', `Coin info not found for hash: ${hash} ${networkInfo.hashGenesisBlock} BTC version:${btcVersion}`);
+    }
+    return result;
+};
+exports.getCoinInfoByHash = getCoinInfoByHash;
+const getCoinInfo = (currency) => (0, exports.getBitcoinNetwork)(currency) || (0, exports.getEthereumNetwork)(currency) || (0, exports.getMiscNetwork)(currency);
+exports.getCoinInfo = getCoinInfo;
+const getCoinName = (path) => {
+    const slip44 = (0, pathUtils_1.fromHardened)(path[1]);
+    const network = ethereumNetworks.find(n => n.slip44 === slip44);
+    return network ? network.name : 'Unknown coin';
+};
+exports.getCoinName = getCoinName;
+const parseBitcoinNetworksJson = (json) => {
+    Object.keys(json).forEach(key => {
+        const coin = json[key];
+        const shortcut = coin.coin_shortcut;
+        const isBitcoin = shortcut === 'BTC' || shortcut === 'TEST';
+        const network = {
+            messagePrefix: coin.signed_message_header,
+            bech32: coin.bech32_prefix,
+            bip32: {
+                public: coin.xpub_magic,
+                private: coin.xprv_magic,
+            },
+            pubKeyHash: coin.address_type,
+            scriptHash: coin.address_type_p2sh,
+            forkId: coin.fork_id,
+            wif: 0,
+        };
+        bitcoinNetworks.push({
+            type: 'bitcoin',
+            blockchainLink: coin.blockchain_link,
+            blocktime: Math.round(coin.blocktime_seconds / 60),
+            cashAddrPrefix: coin.cashaddr_prefix,
+            label: coin.coin_label,
+            name: coin.coin_name,
+            shortcut,
+            curveName: coin.curve_name,
+            defaultFees: coin.default_fee_b,
+            dustLimit: coin.dust_limit,
+            forceBip143: coin.force_bip143,
+            hashGenesisBlock: coin.hash_genesis_block,
+            maxAddressLength: coin.max_address_length,
+            maxFeeSatoshiKb: coin.maxfee_kb,
+            minAddressLength: coin.min_address_length,
+            minFeeSatoshiKb: coin.minfee_kb,
+            segwit: coin.segwit,
+            slip44: coin.slip44,
+            support: coin.support,
+            xPubMagic: coin.xpub_magic,
+            xPubMagicSegwitNative: coin.xpub_magic_segwit_native,
+            xPubMagicSegwit: coin.xpub_magic_segwit_p2sh,
+            taproot: coin.taproot,
+            network,
+            isBitcoin,
+            maxFee: Math.round(coin.maxfee_kb / 1000),
+            minFee: Math.round(coin.minfee_kb / 1000),
+            blocks: Math.round(coin.blocktime_seconds / 60),
+            decimals: coin.decimals,
+        });
+    });
+};
+const parseEthereumNetworksJson = (json) => {
+    Object.keys(json).forEach(key => {
+        const network = json[key];
+        ethereumNetworks.push({
+            type: 'ethereum',
+            blockchainLink: network.blockchain_link,
+            blocktime: -1,
+            chain: network.chain,
+            chainId: network.chain_id,
+            defaultFees: [
+                {
+                    label: 'normal',
+                    feePerUnit: '5000000000',
+                    feeLimit: '21000',
+                },
+            ],
+            minFee: 1,
+            maxFee: 10000,
+            label: network.name,
+            name: network.name,
+            shortcut: network.shortcut,
+            rskip60: network.rskip60,
+            slip44: network.slip44,
+            support: network.support,
+            network: undefined,
+            decimals: 16,
+        });
+    });
+};
+const parseMiscNetworksJSON = (json, type) => {
+    Object.keys(json).forEach(key => {
+        const network = json[key];
+        let minFee = -1;
+        let maxFee = -1;
+        let defaultFees = { Normal: -1 };
+        const shortcut = network.shortcut.toLowerCase();
+        if (shortcut === 'xrp' || shortcut === 'txrp') {
+            minFee = 10;
+            maxFee = 10000;
+            defaultFees = { Normal: 12 };
+        }
+        if (shortcut === 'ada' || shortcut === 'tada') {
+            minFee = 44;
+            maxFee = 16384 * 44 + 155381;
+            defaultFees = { Normal: 44 };
+        }
+        miscNetworks.push({
+            type: type || 'misc',
+            blockchainLink: network.blockchain_link,
+            blocktime: -1,
+            curve: network.curve,
+            defaultFees,
+            minFee,
+            maxFee,
+            label: network.name,
+            name: network.name,
+            shortcut: network.shortcut,
+            slip44: network.slip44,
+            support: network.support,
+            network: undefined,
+            decimals: network.decimals,
+        });
+    });
+};
+const parseCoinsJson = (json) => {
+    Object.keys(json).forEach(key => {
+        switch (key) {
+            case 'bitcoin':
+                return parseBitcoinNetworksJson(json[key]);
+            case 'eth':
+                return parseEthereumNetworksJson(json[key]);
+            case 'misc':
+                return parseMiscNetworksJSON(json[key]);
+            case 'nem':
+                return parseMiscNetworksJSON(json[key], 'nem');
+        }
+    });
+};
+exports.parseCoinsJson = parseCoinsJson;
+const getUniqueNetworks = (networks) => networks.reduce((result, info) => {
+    if (!info || result.find(i => i.shortcut === info.shortcut))
+        return result;
+    return result.concat(info);
+}, []);
+exports.getUniqueNetworks = getUniqueNetworks;
+const getAllNetworks = () => [...bitcoinNetworks, ...ethereumNetworks, ...miscNetworks];
+exports.getAllNetworks = getAllNetworks;
+//# sourceMappingURL=coinInfo.js.map

package/lib/data/config.d.ts

@@ -0,0 +1,98 @@
+export declare const config: {
+    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: {
+        name: string;
+        range: {
+            min: string[];
+        };
+        json: 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;
+    })[];
+};
+//# sourceMappingURL=config.d.ts.map