@trezor/connect 9.0.2 → 9.0.4

package/lib/api/index.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requestLogin = exports.recoveryDevice = exports.rebootToBootloader = exports.pushTransaction = exports.nemSignTransaction = exports.nemGetAddress = exports.getSettings = exports.getPublicKey = exports.getOwnershipProof = exports.getOwnershipId = exports.getFirmwareHash = exports.getFeatures = exports.getDeviceState = exports.getCoinInfo = exports.getAddress = exports.getAccountInfo = exports.firmwareUpdate = exports.ethereumVerifyMessage = exports.ethereumSignTypedData = exports.ethereumSignTransaction = exports.ethereumSignMessage = exports.ethereumGetPublicKey = exports.ethereumGetAddress = exports.eosSignTransaction = exports.eosGetPublicKey = exports.composeTransaction = exports.cipherKeyValue = exports.changePin = exports.cardanoSignTransaction = exports.cardanoGetPublicKey = exports.cardanoGetNativeScriptHash = exports.cardanoGetAddress = exports.blockchainUnsubscribeFiatRates = exports.blockchainUnsubscribe = exports.blockchainSubscribeFiatRates = exports.blockchainSubscribe = exports.blockchainSetCustomBackend = exports.blockchainGetTransactions = exports.blockchainGetFiatRatesForTimestamps = exports.blockchainGetCurrentFiatRates = exports.blockchainGetAccountBalanceHistory = exports.blockchainEstimateFee = exports.blockchainDisconnect = exports.binanceSignTransaction = exports.binanceGetPublicKey = exports.binanceGetAddress = exports.backupDevice = exports.authorizeCoinJoin = exports.applySettings = exports.applyFlags = void 0;
-exports.checkFirmwareAuthenticity = exports.wipeDevice = exports.verifyMessage = exports.tezosSignTransaction = exports.tezosGetPublicKey = exports.tezosGetAddress = exports.stellarSignTransaction = exports.stellarGetAddress = exports.signTransaction = exports.signMessage = exports.setProxy = exports.rippleSignTransaction = exports.rippleGetAddress = exports.resetDevice = void 0;
+exports.checkFirmwareAuthenticity = exports.wipeDevice = exports.verifyMessage = exports.unlockPath = exports.tezosSignTransaction = exports.tezosGetPublicKey = exports.tezosGetAddress = exports.stellarSignTransaction = exports.stellarGetAddress = exports.signTransaction = exports.signMessage = exports.setProxy = exports.setBusy = exports.rippleSignTransaction = exports.rippleGetAddress = exports.resetDevice = void 0;
 var applyFlags_1 = require("./applyFlags");
 Object.defineProperty(exports, "applyFlags", { enumerable: true, get: function () { return __importDefault(applyFlags_1).default; } });
 var applySettings_1 = require("./applySettings");
@@ -111,6 +111,8 @@ var rippleGetAddress_1 = require("./rippleGetAddress");
 Object.defineProperty(exports, "rippleGetAddress", { enumerable: true, get: function () { return __importDefault(rippleGetAddress_1).default; } });
 var rippleSignTransaction_1 = require("./rippleSignTransaction");
 Object.defineProperty(exports, "rippleSignTransaction", { enumerable: true, get: function () { return __importDefault(rippleSignTransaction_1).default; } });
+var setBusy_1 = require("./setBusy");
+Object.defineProperty(exports, "setBusy", { enumerable: true, get: function () { return __importDefault(setBusy_1).default; } });
 var setProxy_1 = require("./setProxy");
 Object.defineProperty(exports, "setProxy", { enumerable: true, get: function () { return __importDefault(setProxy_1).default; } });
 var signMessage_1 = require("./signMessage");
@@ -127,6 +129,8 @@ var tezosGetPublicKey_1 = require("./tezosGetPublicKey");
 Object.defineProperty(exports, "tezosGetPublicKey", { enumerable: true, get: function () { return __importDefault(tezosGetPublicKey_1).default; } });
 var tezosSignTransaction_1 = require("./tezosSignTransaction");
 Object.defineProperty(exports, "tezosSignTransaction", { enumerable: true, get: function () { return __importDefault(tezosSignTransaction_1).default; } });
+var unlockPath_1 = require("./unlockPath");
+Object.defineProperty(exports, "unlockPath", { enumerable: true, get: function () { return __importDefault(unlockPath_1).default; } });
 var verifyMessage_1 = require("./verifyMessage");
 Object.defineProperty(exports, "verifyMessage", { enumerable: true, get: function () { return __importDefault(verifyMessage_1).default; } });
 var wipeDevice_1 = require("./wipeDevice");

package/lib/api/setBusy.d.ts

@@ -0,0 +1,7 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import { PROTO } from '../constants';
+export default class SetBusy extends AbstractMethod<'setBusy', PROTO.SetBusy> {
+    init(): void;
+    run(): Promise<PROTO.Success>;
+}
+//# sourceMappingURL=setBusy.d.ts.map

package/lib/api/setBusy.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+class SetBusy extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.useDeviceState = false;
+        this.requiredPermissions = ['management'];
+        this.keepSession = true;
+        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.params = {
+            expiry_ms: payload.expiry_ms,
+        };
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const { message } = await cmd.typedCall('SetBusy', 'Success', this.params);
+        return message;
+    }
+}
+exports.default = SetBusy;
+//# sourceMappingURL=setBusy.js.map

package/lib/api/signTransaction.d.ts

@@ -6,12 +6,13 @@ declare type Params = {
     inputs: PROTO.TxInputType[];
     outputs: PROTO.TxOutputType[];
     paymentRequests: PROTO.TxAckPaymentRequest[];
+    coinjoinRequest?: PROTO.CoinJoinRequest;
     refTxs?: RefTransaction[];
     addresses?: AccountAddresses;
     options: TransactionOptions;
     coinInfo: BitcoinNetworkInfo;
     push: boolean;
-    preauthorized?: boolean;
+    unlockPath?: PROTO.UnlockPath;
 };
 export default class SignTransaction extends AbstractMethod<'signTransaction', Params> {
     init(): void;

package/lib/api/signTransaction.js

@@ -19,6 +19,7 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
             { name: 'inputs', type: 'array', required: true },
             { name: 'outputs', type: 'array', required: true },
             { name: 'paymentRequests', type: 'array', allowEmpty: true },
+            { name: 'coinjoinRequest', type: 'object' },
             { name: 'refTxs', type: 'array', allowEmpty: true },
             { name: 'account', type: 'object' },
             { name: 'locktime', type: 'number' },
@@ -32,12 +33,21 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
             { name: 'push', type: 'boolean' },
             { name: 'preauthorized', type: 'boolean' },
             { name: 'amountUnit', type: ['number', 'string'] },
+            { name: 'unlockPath', type: 'object' },
+            { name: 'serialize', type: 'boolean' },
         ]);
+        if (payload.unlockPath) {
+            (0, paramsValidator_1.validateParams)(payload.unlockPath, [
+                { name: 'address_n', required: true, type: 'array' },
+                { name: 'mac', required: true, type: 'string' },
+            ]);
+        }
         const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(payload.coin);
         if (!coinInfo) {
             throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
         }
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, this.firmwareRange);
+        this.preauthorized = payload.preauthorized;
         this.info = (0, pathUtils_1.getLabel)('Sign #NETWORK transaction', coinInfo);
         const inputs = (0, bitcoin_1.validateTrezorInputs)(payload.inputs, coinInfo);
         const outputs = (0, bitcoin_1.validateTrezorOutputs)(payload.outputs, coinInfo);
@@ -66,10 +76,12 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
                 branch_id: payload.branchId,
                 decred_staking_ticket: payload.decredStakingTicket,
                 amount_unit: payload.amountUnit,
+                serialize: payload.serialize,
+                coinjoin_request: payload.coinjoinRequest,
             },
             coinInfo,
             push: typeof payload.push === 'boolean' ? payload.push : false,
-            preauthorized: payload.preauthorized,
+            unlockPath: payload.unlockPath,
         };
         this.params.options = (0, bitcoin_1.enhanceSignTx)(this.params.options, coinInfo);
     }
@@ -95,9 +107,10 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
                         if (!accountPath || !accountPath.address_n) {
                             throw constants_1.ERRORS.TypedError('Runtime', 'Account not found');
                         }
+                        const address_n = accountPath.address_n.slice(0, 3);
                         const node = await device
                             .getCommands()
-                            .getHDNode(accountPath.address_n.slice(0, 3), params.coinInfo);
+                            .getHDNode({ address_n }, { coinInfo: params.coinInfo });
                         const account = await blockchain.getAccountInfo({
                             descriptor: node.xpubSegwit || node.xpub,
                             details: 'tokens',
@@ -112,8 +125,11 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
         else {
             refTxs = params.refTxs;
         }
-        if (params.preauthorized) {
-            await device.getCommands().typedCall('DoPreauthorized', 'PreauthorizedRequest', {});
+        if (this.preauthorized) {
+            await device.getCommands().preauthorize(true);
+        }
+        else if (params.unlockPath) {
+            await device.getCommands().unlockPath(params.unlockPath);
         }
         const signTxMethod = !useLegacySignProcess ? bitcoin_1.signTx : bitcoin_1.signTxLegacy;
         const response = await signTxMethod({
@@ -121,11 +137,14 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
             refTxs,
             typedCall: device.getCommands().typedCall.bind(device.getCommands()),
         });
+        if (!response.serializedTx) {
+            return response;
+        }
         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);
+            const 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'); });
             }

package/lib/api/unlockPath.d.ts

@@ -0,0 +1,10 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import { PROTO } from '../constants';
+export default class UnlockPath extends AbstractMethod<'unlockPath', PROTO.UnlockPath> {
+    init(): void;
+    run(): Promise<{
+        address_n: number[];
+        mac: string | undefined;
+    }>;
+}
+//# sourceMappingURL=unlockPath.d.ts.map

package/lib/api/unlockPath.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const pathUtils_1 = require("../utils/pathUtils");
+const paramsValidator_1 = require("./common/paramsValidator");
+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' },
+        });
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'path', required: true },
+            { name: 'mac', type: 'string' },
+        ]);
+        const path = (0, pathUtils_1.validatePath)(payload.path, 1);
+        this.params = {
+            address_n: path,
+            mac: payload.mac,
+        };
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const { message } = await cmd.unlockPath(this.params);
+        return {
+            address_n: this.params.address_n,
+            mac: message.mac,
+        };
+    }
+}
+exports.default = UnlockPath;
+//# sourceMappingURL=unlockPath.js.map

package/lib/backend/BackendManager.d.ts

@@ -0,0 +1,21 @@
+import { Blockchain, BlockchainOptions } from './Blockchain';
+import type { CoinInfo, BlockchainLink } from '../types';
+declare type CoinShortcut = CoinInfo['shortcut'];
+export declare class BackendManager {
+    private readonly instances;
+    private readonly custom;
+    private readonly preferred;
+    get(shortcut: CoinShortcut): Blockchain | null;
+    remove(shortcut: CoinShortcut): void;
+    getOrConnect(coinInfo: CoinInfo, postMessage: BlockchainOptions['postMessage']): Promise<Blockchain>;
+    dispose(): void;
+    reconnectAll(): Promise<Blockchain[]>;
+    isSupported(coinInfo: CoinInfo): void;
+    setCustom(shortcut: CoinShortcut, blockchainLink: BlockchainLink): void;
+    removeCustom(shortcut: CoinShortcut): void;
+    private setPreferred;
+    private removePreferred;
+    private patchCoinInfo;
+}
+export {};
+//# sourceMappingURL=BackendManager.d.ts.map

package/lib/backend/BackendManager.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackendManager = void 0;
+const config_1 = require("../data/config");
+const DataManager_1 = require("../data/DataManager");
+const constants_1 = require("../constants");
+const Blockchain_1 = require("./Blockchain");
+class BackendManager {
+    constructor() {
+        this.instances = {};
+        this.custom = {};
+        this.preferred = {};
+    }
+    get(shortcut) {
+        var _a;
+        return (_a = this.instances[shortcut]) !== null && _a !== void 0 ? _a : null;
+    }
+    remove(shortcut) {
+        delete this.instances[shortcut];
+    }
+    async getOrConnect(coinInfo, postMessage) {
+        let backend = this.get(coinInfo.shortcut);
+        if (!backend) {
+            backend = new Blockchain_1.Blockchain({
+                coinInfo: this.patchCoinInfo(coinInfo),
+                postMessage,
+                debug: DataManager_1.DataManager.getSettings('debug'),
+                proxy: DataManager_1.DataManager.getSettings('proxy'),
+                onionDomains: DataManager_1.DataManager.getSettings('useOnionLinks') && !this.custom[coinInfo.shortcut]
+                    ? config_1.config.onionDomains
+                    : undefined,
+                onConnected: url => this.setPreferred(coinInfo.shortcut, url),
+                onDisconnected: () => this.remove(coinInfo.shortcut),
+            });
+            this.instances[coinInfo.shortcut] = backend;
+            try {
+                await backend.init();
+            }
+            catch (error) {
+                this.remove(coinInfo.shortcut);
+                this.removePreferred(coinInfo.shortcut);
+                throw error;
+            }
+        }
+        return backend;
+    }
+    dispose() {
+        Object.values(this.instances).forEach(i => i.disconnect());
+    }
+    reconnectAll() {
+        const params = Object.values(this.instances).map(i => [i.coinInfo, i.postMessage]);
+        Object.values(this.instances).forEach(i => i.disconnect());
+        return Promise.all(params.map(p => this.getOrConnect(...p)));
+    }
+    isSupported(coinInfo) {
+        const info = this.custom[coinInfo.shortcut] || coinInfo.blockchainLink;
+        if (!info) {
+            throw constants_1.ERRORS.TypedError('Backend_NotSupported');
+        }
+    }
+    setCustom(shortcut, blockchainLink) {
+        this.removePreferred(shortcut);
+        this.custom[shortcut] = blockchainLink;
+    }
+    removeCustom(shortcut) {
+        this.removePreferred(shortcut);
+        delete this.custom[shortcut];
+    }
+    setPreferred(shortcut, url) {
+        this.preferred[shortcut] = url;
+    }
+    removePreferred(shortcut) {
+        delete this.preferred[shortcut];
+    }
+    patchCoinInfo(coinInfo) {
+        var _a, _b;
+        const custom = this.custom[coinInfo.shortcut];
+        const preferred = this.preferred[coinInfo.shortcut];
+        const url = preferred ? [preferred] : (_a = custom === null || custom === void 0 ? void 0 : custom.url) !== null && _a !== void 0 ? _a : (_b = coinInfo.blockchainLink) === null || _b === void 0 ? void 0 : _b.url;
+        return {
+            ...coinInfo,
+            blockchainLink: {
+                ...coinInfo.blockchainLink,
+                ...custom,
+                url,
+            },
+        };
+    }
+}
+exports.BackendManager = BackendManager;
+//# sourceMappingURL=BackendManager.js.map

package/lib/backend/Blockchain.d.ts

@@ -0,0 +1,72 @@
+import BlockchainLink, { ServerInfo, SubscriptionAccountInfo, BlockchainLinkParams, BlockchainLinkResponse } from '@trezor/blockchain-link';
+import { ERRORS } from '../constants';
+import type { CoinInfo, Proxy } from '../types';
+import type { CoreMessage } from '../events';
+export declare type BlockchainOptions = {
+    coinInfo: CoinInfo;
+    postMessage: (message: CoreMessage) => void;
+    proxy?: Proxy;
+    onionDomains?: {
+        [domain: string]: string;
+    };
+    debug?: boolean;
+    onConnected?: (url: string) => void;
+    onDisconnected?: () => void;
+};
+export declare class Blockchain {
+    link: BlockchainLink;
+    serverInfo?: ServerInfo;
+    coinInfo: BlockchainOptions['coinInfo'];
+    onionDomains: {
+        [onion: string]: string;
+    };
+    postMessage: BlockchainOptions['postMessage'];
+    feeForBlock: BlockchainLinkResponse<'estimateFee'>;
+    feeTimestamp: number;
+    private onConnected;
+    private onDisconnected;
+    constructor(options: BlockchainOptions);
+    onError(error: ERRORS.TrezorError): void;
+    init(): Promise<void>;
+    getTransactions(txs: string[]): Promise<import("@trezor/blockchain-link").TypedRawTransaction[]>;
+    getCurrentFiatRates(params: {
+        currencies?: string[];
+    }): Promise<{
+        ts: number;
+        rates: import("@trezor/blockchain-link").FiatRates;
+    }>;
+    getFiatRatesForTimestamps(params: {
+        timestamps: number[];
+    }): Promise<{
+        tickers: {
+            ts: number;
+            rates: import("@trezor/blockchain-link").FiatRates;
+        }[];
+    }>;
+    getAccountBalanceHistory(params: BlockchainLinkParams<'getAccountBalanceHistory'>): Promise<import("@trezor/blockchain-link").AccountBalanceHistory[]>;
+    getNetworkInfo(): Promise<ServerInfo>;
+    getAccountInfo(request: BlockchainLinkParams<'getAccountInfo'>): Promise<import("@trezor/blockchain-link").AccountInfo>;
+    getAccountUtxo(descriptor: string): Promise<import("@trezor/blockchain-link").Utxo[]>;
+    estimateFee(request: {
+        blocks?: number[];
+    }): Promise<{
+        feePerUnit: string;
+        feePerTx?: string | undefined;
+        feeLimit?: string | undefined;
+    }[]>;
+    subscribe(accounts?: SubscriptionAccountInfo[]): Promise<{
+        subscribed: boolean;
+    }>;
+    subscribeFiatRates(_currency?: string): Promise<{
+        subscribed: boolean;
+    }>;
+    unsubscribe(accounts?: SubscriptionAccountInfo[]): Promise<{
+        subscribed: boolean;
+    }>;
+    unsubscribeFiatRates(): Promise<{
+        subscribed: boolean;
+    }>;
+    pushTransaction(tx: string): Promise<string>;
+    disconnect(): void;
+}
+//# sourceMappingURL=Blockchain.d.ts.map

package/lib/backend/Blockchain.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Blockchain = void 0;
+const tslib_1 = require("tslib");
+const blockchain_link_1 = tslib_1.__importDefault(require("@trezor/blockchain-link"));
+const events_1 = require("../events");
+const constants_1 = require("../constants");
+const urlUtils_1 = require("../utils/urlUtils");
+const workers_1 = require("../workers/workers");
+const getWorker = (type) => {
+    switch (type) {
+        case 'blockbook':
+            return workers_1.BlockbookWorker;
+        case 'ripple':
+            return workers_1.RippleWorker;
+        case 'blockfrost':
+            return workers_1.BlockfrostWorker;
+        case 'electrum':
+            return workers_1.ElectrumWorker;
+        default:
+            return null;
+    }
+};
+class Blockchain {
+    constructor(options) {
+        this.feeForBlock = [];
+        this.feeTimestamp = 0;
+        this.coinInfo = options.coinInfo;
+        this.postMessage = options.postMessage;
+        this.onConnected = options.onConnected;
+        this.onDisconnected = options.onDisconnected;
+        const { blockchainLink } = options.coinInfo;
+        if (!blockchainLink) {
+            throw constants_1.ERRORS.TypedError('Backend_NotSupported');
+        }
+        const worker = getWorker(blockchainLink.type);
+        if (!worker) {
+            throw constants_1.ERRORS.TypedError('Backend_WorkerMissing', `BlockchainLink worker not found ${blockchainLink.type}`);
+        }
+        const { onionDomains } = options;
+        this.onionDomains = onionDomains
+            ? blockchainLink.url.reduce((a, url) => {
+                const onion = (0, urlUtils_1.getOnionDomain)(url, onionDomains);
+                if (onion !== url) {
+                    a[onion] = url;
+                }
+                return a;
+            }, {})
+            : {};
+        const server = Object.keys(this.onionDomains).length
+            ? Object.keys(this.onionDomains)
+            : blockchainLink.url;
+        this.link = new blockchain_link_1.default({
+            name: this.coinInfo.shortcut,
+            worker,
+            server,
+            debug: options.debug,
+            proxy: options.proxy,
+        });
+    }
+    onError(error) {
+        var _a;
+        this.link.dispose();
+        this.postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.ERROR, {
+            coin: this.coinInfo,
+            error: error.message,
+            code: error.code,
+        }));
+        (_a = this.onDisconnected) === null || _a === void 0 ? void 0 : _a.call(this);
+    }
+    async init() {
+        this.link.on('connected', async () => {
+            var _a;
+            const info = await this.link.getInfo();
+            this.serverInfo = info;
+            const shortcut = this.coinInfo.shortcut === 'tXRP' ? 'XRP' : this.coinInfo.shortcut;
+            if (info.shortcut.toLowerCase() !== shortcut.toLowerCase()) {
+                this.onError(constants_1.ERRORS.TypedError('Backend_Invalid'));
+                return;
+            }
+            const cleanUrl = this.onionDomains[info.url];
+            (_a = this.onConnected) === null || _a === void 0 ? void 0 : _a.call(this, cleanUrl || info.url);
+            this.postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.CONNECT, {
+                coin: this.coinInfo,
+                ...info,
+                cleanUrl,
+            }));
+        });
+        this.link.on('disconnected', () => {
+            this.onError(constants_1.ERRORS.TypedError('Backend_Disconnected'));
+        });
+        this.link.on('error', error => {
+            this.onError(constants_1.ERRORS.TypedError('Backend_Error', error.message));
+        });
+        try {
+            await this.link.connect();
+        }
+        catch (error) {
+            this.onError(constants_1.ERRORS.TypedError('Backend_Error', error.message));
+            throw error;
+        }
+    }
+    getTransactions(txs) {
+        return Promise.all(txs.map(id => this.link.getTransaction(id)));
+    }
+    getCurrentFiatRates(params) {
+        return this.link.getCurrentFiatRates(params);
+    }
+    getFiatRatesForTimestamps(params) {
+        return this.link.getFiatRatesForTimestamps(params);
+    }
+    getAccountBalanceHistory(params) {
+        return this.link.getAccountBalanceHistory(params);
+    }
+    getNetworkInfo() {
+        return this.link.getInfo();
+    }
+    getAccountInfo(request) {
+        return this.link.getAccountInfo(request);
+    }
+    getAccountUtxo(descriptor) {
+        return this.link.getAccountUtxo(descriptor);
+    }
+    async estimateFee(request) {
+        const { blocks } = request;
+        if (blocks) {
+            const now = Date.now();
+            const outdated = now - this.feeTimestamp > 20 * 60 * 1000;
+            const unknownBlocks = blocks.filter(() => typeof this.feeForBlock !== 'string');
+            if (!outdated && unknownBlocks.length < 1) {
+            }
+            const fees = await this.link.estimateFee(request);
+            blocks.forEach((block, index) => {
+                this.feeForBlock[block] = fees[index];
+            });
+            this.feeTimestamp = now;
+            return fees;
+        }
+        return this.link.estimateFee(request);
+    }
+    async subscribe(accounts) {
+        if (this.link.listenerCount('block') === 0) {
+            this.link.on('block', block => {
+                this.postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.BLOCK, {
+                    coin: this.coinInfo,
+                    ...block,
+                }));
+            });
+        }
+        if (this.link.listenerCount('notification') === 0) {
+            this.link.on('notification', notification => {
+                this.postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.NOTIFICATION, {
+                    coin: this.coinInfo,
+                    notification,
+                }));
+            });
+        }
+        const blockSubscription = await this.link.subscribe({ type: 'block' });
+        if (!accounts) {
+            return blockSubscription;
+        }
+        return this.link.subscribe({
+            type: 'accounts',
+            accounts,
+        });
+    }
+    subscribeFiatRates(_currency) {
+        if (this.link.listenerCount('fiatRates') === 0) {
+            this.link.on('fiatRates', ({ rates }) => {
+                this.postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.FIAT_RATES_UPDATE, {
+                    coin: this.coinInfo,
+                    rates,
+                }));
+            });
+        }
+        return this.link.subscribe({
+            type: 'fiatRates',
+        });
+    }
+    async unsubscribe(accounts) {
+        if (!accounts) {
+            this.link.removeAllListeners('block');
+            this.link.removeAllListeners('fiatRates');
+            this.link.removeAllListeners('notification');
+            await this.link.unsubscribe({ type: 'fiatRates' });
+            return this.link.unsubscribe({ type: 'block' });
+        }
+        return this.link.unsubscribe({ type: 'accounts', accounts });
+    }
+    unsubscribeFiatRates() {
+        this.link.removeAllListeners('fiatRates');
+        return this.link.unsubscribe({ type: 'fiatRates' });
+    }
+    pushTransaction(tx) {
+        return this.link.pushTransaction(tx);
+    }
+    disconnect() {
+        this.link.removeAllListeners();
+        this.link.disconnect();
+        this.onError(constants_1.ERRORS.TypedError('Backend_Disconnected'));
+    }
+}
+exports.Blockchain = Blockchain;
+//# sourceMappingURL=Blockchain.js.map