@trezor/connect 9.0.0-beta.1

package/lib/core/index.js

@@ -0,0 +1,671 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initTransport = exports.init = exports.initCore = exports.Core = exports.onCall = exports.handleMessage = void 0;
+const tslib_1 = require("tslib");
+const events_1 = (0, tslib_1.__importDefault)(require("events"));
+const DataManager_1 = require("../data/DataManager");
+const DeviceList_1 = require("../device/DeviceList");
+const constants_1 = require("../constants");
+const events_2 = require("../events");
+const method_1 = require("./method");
+const deferred_1 = require("../utils/deferred");
+const promiseUtils_1 = require("../utils/promiseUtils");
+const debug_1 = require("../utils/debug");
+const BlockchainLink_1 = require("../backend/BlockchainLink");
+const interactionTimeout_1 = require("../utils/interactionTimeout");
+let _core;
+let _deviceList;
+let _popupPromise;
+let _uiPromises = [];
+const _callMethods = [];
+let _preferredDevice;
+let _interactionTimeout;
+const _log = (0, debug_1.initLog)('Core');
+const postMessage = (message) => {
+    if (message.event === events_2.RESPONSE_EVENT) {
+        const index = _callMethods.findIndex(call => call && call.responseID === message.id);
+        if (index >= 0) {
+            _callMethods.splice(index, 1);
+        }
+    }
+    _core.emit(events_2.CORE_EVENT, message);
+};
+const getPopupPromise = (requestWindow = true) => {
+    if (requestWindow) {
+        postMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_UI_WINDOW));
+    }
+    if (!_popupPromise) {
+        _popupPromise = (0, deferred_1.create)();
+    }
+    return _popupPromise;
+};
+const interactionTimeout = () => _interactionTimeout.start(() => {
+    onPopupClosed('Interaction timeout');
+});
+const createUiPromise = (promiseEvent, device) => {
+    const uiPromise = (0, deferred_1.create)(promiseEvent, device);
+    _uiPromises.push(uiPromise);
+    interactionTimeout();
+    return uiPromise;
+};
+const findUiPromise = (promiseEvent) => _uiPromises.find(p => p.id === promiseEvent);
+const removeUiPromise = (promise) => {
+    _uiPromises = _uiPromises.filter(p => p !== promise);
+};
+const handleMessage = (message, isTrustedOrigin = false) => {
+    _log.debug('handleMessage', isTrustedOrigin, message);
+    const safeMessages = [
+        events_2.IFRAME.CALL,
+        events_2.POPUP.CLOSED,
+        events_2.UI.CUSTOM_MESSAGE_RESPONSE,
+        events_2.UI.LOGIN_CHALLENGE_RESPONSE,
+        events_2.TRANSPORT.DISABLE_WEBUSB,
+    ];
+    if (!isTrustedOrigin && safeMessages.indexOf(message.type) === -1) {
+        return;
+    }
+    switch (message.type) {
+        case events_2.POPUP.HANDSHAKE:
+            getPopupPromise(false).resolve();
+            break;
+        case events_2.POPUP.CLOSED:
+            onPopupClosed(message.payload ? message.payload.error : null);
+            break;
+        case events_2.TRANSPORT.DISABLE_WEBUSB:
+            disableWebUSBTransport();
+            break;
+        case events_2.UI.RECEIVE_DEVICE:
+        case events_2.UI.RECEIVE_CONFIRMATION:
+        case events_2.UI.RECEIVE_PERMISSION:
+        case events_2.UI.RECEIVE_PIN:
+        case events_2.UI.RECEIVE_PASSPHRASE:
+        case events_2.UI.INVALID_PASSPHRASE_ACTION:
+        case events_2.UI.RECEIVE_ACCOUNT:
+        case events_2.UI.RECEIVE_FEE:
+        case events_2.UI.CUSTOM_MESSAGE_RESPONSE:
+        case events_2.UI.RECEIVE_WORD:
+        case events_2.UI.LOGIN_CHALLENGE_RESPONSE: {
+            const uiPromise = findUiPromise(message.type);
+            if (uiPromise) {
+                uiPromise.resolve(message);
+                removeUiPromise(uiPromise);
+            }
+            break;
+        }
+        case events_2.IFRAME.CALL:
+            (0, exports.onCall)(message).catch(error => {
+                _log.error('onCall', error);
+            });
+            break;
+    }
+};
+exports.handleMessage = handleMessage;
+const initDevice = async (method) => {
+    if (!_deviceList) {
+        throw constants_1.ERRORS.TypedError('Transport_Missing');
+    }
+    const isWebUsb = _deviceList.transportType() === 'WebUsbPlugin';
+    let device;
+    let showDeviceSelection = isWebUsb;
+    if (method.devicePath) {
+        device = _deviceList.getDevice(method.devicePath);
+        showDeviceSelection = !!(device === null || device === void 0 ? void 0 : device.unreadableError);
+    }
+    else {
+        const devices = _deviceList.asArray();
+        if (devices.length === 1 && !isWebUsb) {
+            device = _deviceList.getDevice(devices[0].path);
+            showDeviceSelection = !!(device === null || device === void 0 ? void 0 : device.unreadableError);
+        }
+        else {
+            showDeviceSelection = true;
+        }
+    }
+    if (showDeviceSelection) {
+        createUiPromise(events_2.UI.RECEIVE_DEVICE);
+        await getPopupPromise().promise;
+        const devices = _deviceList.asArray();
+        if (devices.length === 1 && devices[0].type !== 'unreadable' && !isWebUsb) {
+            device = _deviceList.getDevice(devices[0].path);
+        }
+        else {
+            postMessage((0, events_2.createUiMessage)(events_2.UI.SELECT_DEVICE, {
+                webusb: isWebUsb,
+                devices: _deviceList.asArray(),
+            }));
+            const uiPromise = findUiPromise(events_2.UI.RECEIVE_DEVICE);
+            if (uiPromise) {
+                const { payload } = await uiPromise.promise;
+                if (payload.remember) {
+                    _preferredDevice = payload.device;
+                }
+                device = _deviceList.getDevice(payload.device.path);
+            }
+        }
+    }
+    if (!device) {
+        throw constants_1.ERRORS.TypedError('Device_NotFound');
+    }
+    return device;
+};
+const onCall = async (message) => {
+    var _a;
+    if (!message.id || !message.payload || message.type !== events_2.IFRAME.CALL) {
+        throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'onCall: message.id or message.payload is missing');
+    }
+    const responseID = message.id;
+    const trustedHost = DataManager_1.DataManager.getSettings('trustedHost');
+    const isUsingPopup = DataManager_1.DataManager.getSettings('popup');
+    if (_preferredDevice && !message.payload.device) {
+        message.payload.device = _preferredDevice;
+    }
+    let method;
+    let messageResponse;
+    try {
+        method = (0, method_1.getMethod)(message);
+        method.postMessage = postMessage;
+        method.getPopupPromise = getPopupPromise;
+        method.createUiPromise = createUiPromise;
+        method.init();
+    }
+    catch (error) {
+        postMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
+        postMessage((0, events_2.createResponseMessage)(responseID, false, { error }));
+        return Promise.resolve();
+    }
+    _callMethods.push(method);
+    if (!method.useDevice) {
+        try {
+            if (method.useUi) {
+                await getPopupPromise().promise;
+            }
+            else {
+                postMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
+            }
+            const response = await method.run();
+            messageResponse = (0, events_2.createResponseMessage)(method.responseID, true, response);
+        }
+        catch (error) {
+            messageResponse = (0, events_2.createResponseMessage)(method.responseID, false, { error });
+        }
+        postMessage(messageResponse);
+        return Promise.resolve();
+    }
+    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()) {
+        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'),
+        }));
+        return Promise.resolve();
+    }
+    let device;
+    try {
+        device = await initDevice(method);
+    }
+    catch (error) {
+        if (error.code === 'Transport_Missing') {
+            await getPopupPromise().promise;
+            postMessage((0, events_2.createUiMessage)(events_2.UI.TRANSPORT));
+        }
+        else {
+            postMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
+        }
+        postMessage((0, events_2.createResponseMessage)(responseID, false, { error }));
+        throw error;
+    }
+    method.setDevice(device);
+    const previousCall = _callMethods.filter(call => call && call !== method && call.devicePath === method.devicePath);
+    if (previousCall.length > 0 && method.overridePreviousCall) {
+        previousCall.forEach(call => {
+            call.overridden = true;
+        });
+        const overrideError = constants_1.ERRORS.TypedError('Method_Override');
+        await device.override(overrideError);
+        if (method.overridden) {
+            postMessage((0, events_2.createResponseMessage)(method.responseID, false, { error: overrideError }));
+            throw overrideError;
+        }
+    }
+    else if (device.isRunning()) {
+        if (!device.isLoaded()) {
+            await device.waitForFirstRun();
+        }
+        else {
+            postMessage((0, events_2.createResponseMessage)(responseID, false, {
+                error: constants_1.ERRORS.TypedError('Device_CallInProgress'),
+            }));
+            throw constants_1.ERRORS.TypedError('Device_CallInProgress');
+        }
+    }
+    device.setInstance((_a = message.payload.device) === null || _a === void 0 ? void 0 : _a.instance);
+    if (method.hasExpectedDeviceState) {
+        device.setExternalState(method.deviceState);
+    }
+    device.on(events_2.DEVICE.BUTTON, (d, code) => {
+        onDeviceButtonHandler(d, code, method);
+    });
+    device.on(events_2.DEVICE.PIN, onDevicePinHandler);
+    device.on(events_2.DEVICE.WORD, onDeviceWordHandler);
+    device.on(events_2.DEVICE.PASSPHRASE, method.useEmptyPassphrase ? onEmptyPassphraseHandler : onDevicePassphraseHandler);
+    device.on(events_2.DEVICE.PASSPHRASE_ON_DEVICE, () => {
+        postMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PASSPHRASE_ON_DEVICE, { device: device.toMessageObject() }));
+    });
+    if (_deviceList) {
+        await _deviceList.reconfigure(device.getVersion());
+    }
+    try {
+        let PIN_TRIES = 1;
+        const MAX_PIN_TRIES = 3;
+        const inner = async () => {
+            const firmwareException = await method.checkFirmwareRange(isUsingPopup);
+            if (firmwareException) {
+                if (isUsingPopup) {
+                    await getPopupPromise().promise;
+                    postMessage((0, events_2.createUiMessage)(firmwareException, device.toMessageObject()));
+                    await createUiPromise(events_2.DEVICE.DISCONNECT, device).promise;
+                    return Promise.reject(constants_1.ERRORS.TypedError('Method_Cancel'));
+                }
+                return Promise.reject(constants_1.ERRORS.TypedError('Device_FwException', firmwareException));
+            }
+            const unexpectedMode = device.hasUnexpectedMode(method.allowDeviceMode, method.requireDeviceMode);
+            if (unexpectedMode) {
+                device.keepSession = false;
+                if (isUsingPopup) {
+                    await getPopupPromise().promise;
+                    postMessage((0, events_2.createUiMessage)(unexpectedMode, device.toMessageObject()));
+                    await createUiPromise(events_2.DEVICE.DISCONNECT, device).promise;
+                    return Promise.reject(constants_1.ERRORS.TypedError('Device_ModeException', unexpectedMode));
+                }
+                return Promise.reject(constants_1.ERRORS.TypedError('Device_ModeException', unexpectedMode));
+            }
+            method.checkPermissions();
+            if (!trustedHost && method.requiredPermissions.length > 0) {
+                const permitted = await method.requestPermissions();
+                if (!permitted) {
+                    return Promise.reject(constants_1.ERRORS.TypedError('Method_PermissionsNotGranted'));
+                }
+            }
+            const deviceNeedsBackup = device.features.needs_backup;
+            if (deviceNeedsBackup && typeof method.noBackupConfirmation === 'function') {
+                const permitted = await method.noBackupConfirmation();
+                if (!permitted) {
+                    return Promise.reject(constants_1.ERRORS.TypedError('Method_PermissionsNotGranted'));
+                }
+            }
+            if (deviceNeedsBackup) {
+                await getPopupPromise().promise;
+                postMessage((0, events_2.createUiMessage)(events_2.UI.DEVICE_NEEDS_BACKUP, device.toMessageObject()));
+            }
+            if (device.firmwareStatus === 'outdated') {
+                await getPopupPromise().promise;
+                postMessage((0, events_2.createUiMessage)(events_2.UI.FIRMWARE_OUTDATED, device.toMessageObject()));
+            }
+            if (!trustedHost && typeof method.confirmation === 'function') {
+                const confirmed = await method.confirmation();
+                if (!confirmed) {
+                    return Promise.reject(constants_1.ERRORS.TypedError('Method_Cancel'));
+                }
+            }
+            if (_deviceList) {
+                await _deviceList.reconfigure(device.getVersion());
+            }
+            try {
+                const invalidDeviceState = method.useDeviceState
+                    ? await device.validateState(method.network)
+                    : undefined;
+                if (invalidDeviceState) {
+                    if (isUsingPopup) {
+                        const uiPromise = createUiPromise(events_2.UI.INVALID_PASSPHRASE_ACTION, device);
+                        postMessage((0, events_2.createUiMessage)(events_2.UI.INVALID_PASSPHRASE, {
+                            device: device.toMessageObject(),
+                        }));
+                        const uiResp = await uiPromise.promise;
+                        if (uiResp.payload) {
+                            device.setInternalState(undefined);
+                            await device.initialize(method.useEmptyPassphrase, method.useCardanoDerivation);
+                            return inner();
+                        }
+                        device.setExternalState(invalidDeviceState);
+                    }
+                    else {
+                        throw constants_1.ERRORS.TypedError('Device_InvalidState');
+                    }
+                }
+            }
+            catch (error) {
+                if (error.message === constants_1.ERRORS.INVALID_PIN_ERROR_MESSAGE &&
+                    PIN_TRIES < MAX_PIN_TRIES) {
+                    PIN_TRIES++;
+                    postMessage((0, events_2.createUiMessage)(events_2.UI.INVALID_PIN, { device: device.toMessageObject() }));
+                    return inner();
+                }
+                device.setInternalState(undefined);
+                return Promise.reject(error);
+            }
+            if (method.useUi) {
+                await getPopupPromise().promise;
+            }
+            else {
+                postMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
+            }
+            try {
+                const customMessages = method.getCustomMessages();
+                if (_deviceList && customMessages) {
+                    await _deviceList.reconfigure(customMessages, true);
+                }
+                const response = await method.run();
+                messageResponse = (0, events_2.createResponseMessage)(method.responseID, true, response);
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        };
+        await device.run(inner, {
+            keepSession: method.keepSession,
+            useEmptyPassphrase: method.useEmptyPassphrase,
+            skipFinalReload: method.skipFinalReload,
+            useCardanoDerivation: method.useCardanoDerivation,
+        });
+    }
+    catch (error) {
+        if (_deviceList && error.code === 'Device_Disconnected') {
+            _deviceList.addAuthPenalty(device);
+        }
+        if (method) {
+            if (_deviceList && error.message === constants_1.ERRORS.WRONG_PREVIOUS_SESSION_ERROR_MESSAGE) {
+                _deviceList.enumerate();
+            }
+            messageResponse = (0, events_2.createResponseMessage)(method.responseID, false, { error });
+        }
+    }
+    finally {
+        const response = messageResponse;
+        if (response) {
+            if (method.name === 'rebootToBootloader' && response.success) {
+                await (0, promiseUtils_1.resolveAfter)(1000);
+                await device.run(() => Promise.resolve(), { skipFinalReload: true });
+            }
+            await device.cleanup();
+            closePopup();
+            cleanup();
+            if (method) {
+                method.dispose();
+            }
+            if (_deviceList) {
+                if (response.success) {
+                    _deviceList.removeAuthPenalty(device);
+                }
+                await _deviceList.restoreMessages();
+            }
+            postMessage(response);
+        }
+    }
+};
+exports.onCall = onCall;
+const cleanup = () => {
+    _popupPromise = undefined;
+    _uiPromises = [];
+    _interactionTimeout.stop();
+    _log.debug('Cleanup...');
+};
+const closePopup = () => {
+    if (_popupPromise) {
+        postMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
+    }
+    postMessage((0, events_2.createUiMessage)(events_2.UI.CLOSE_UI_WINDOW));
+};
+const onDeviceButtonHandler = async (...[device, request, method]) => {
+    const addressRequest = request.code === 'ButtonRequest_Address';
+    if (!addressRequest || (addressRequest && method.useUi)) {
+        await getPopupPromise().promise;
+    }
+    const data = typeof method.getButtonRequestData === 'function' && request.code
+        ? method.getButtonRequestData(request.code)
+        : undefined;
+    interactionTimeout();
+    postMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.BUTTON, { ...request, device: device.toMessageObject() }));
+    postMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_BUTTON, {
+        ...request,
+        device: device.toMessageObject(),
+        data,
+    }));
+    if (addressRequest && !method.useUi) {
+        postMessage((0, events_2.createUiMessage)(events_2.UI.ADDRESS_VALIDATION, data));
+    }
+};
+const onDevicePinHandler = async (...[device, type, callback]) => {
+    await getPopupPromise().promise;
+    const uiPromise = createUiPromise(events_2.UI.RECEIVE_PIN, device);
+    postMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PIN, { device: device.toMessageObject(), type }));
+    const uiResp = await uiPromise.promise;
+    callback(null, uiResp.payload);
+};
+const onDeviceWordHandler = async (...[device, type, callback]) => {
+    await getPopupPromise().promise;
+    const uiPromise = createUiPromise(events_2.UI.RECEIVE_WORD, device);
+    postMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_WORD, { device: device.toMessageObject(), type }));
+    const uiResp = await uiPromise.promise;
+    callback(null, uiResp.payload);
+};
+const onDevicePassphraseHandler = async (...[device, callback]) => {
+    await getPopupPromise().promise;
+    const uiPromise = createUiPromise(events_2.UI.RECEIVE_PASSPHRASE, device);
+    postMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PASSPHRASE, { device: device.toMessageObject() }));
+    const uiResp = await uiPromise.promise;
+    const { value, passphraseOnDevice, save } = uiResp.payload;
+    callback({
+        passphrase: value.normalize('NFKD'),
+        passphraseOnDevice,
+        cache: save,
+    });
+};
+const onEmptyPassphraseHandler = (...[_, callback]) => {
+    callback({ passphrase: '' });
+};
+const onPopupClosed = (customErrorMessage) => {
+    const error = customErrorMessage
+        ? constants_1.ERRORS.TypedError('Method_Cancel', customErrorMessage)
+        : constants_1.ERRORS.TypedError('Method_Interrupted');
+    if (_deviceList && _deviceList.asArray().length > 0) {
+        _deviceList.allDevices().forEach(d => {
+            d.keepSession = false;
+            if (d.isUsedHere()) {
+                d.interruptionFromUser(error);
+            }
+            else {
+                const uiPromise = findUiPromise(events_2.DEVICE.DISCONNECT);
+                if (uiPromise) {
+                    uiPromise.resolve({ type: events_2.DEVICE.DISCONNECT, payload: undefined });
+                }
+                else {
+                    _callMethods.forEach(m => {
+                        postMessage((0, events_2.createResponseMessage)(m.responseID, false, { error }));
+                    });
+                    _callMethods.splice(0, _callMethods.length);
+                }
+            }
+        });
+        cleanup();
+    }
+    else {
+        if (_uiPromises.length > 0) {
+            _uiPromises.forEach(p => {
+                p.reject(error);
+            });
+            _uiPromises = [];
+        }
+        if (_popupPromise) {
+            _popupPromise.reject(error);
+            _popupPromise = undefined;
+        }
+        cleanup();
+    }
+};
+const handleDeviceSelectionChanges = (interruptDevice) => {
+    const uiPromise = findUiPromise(events_2.UI.RECEIVE_DEVICE);
+    if (uiPromise && _deviceList) {
+        const list = _deviceList.asArray();
+        const isWebUsb = _deviceList.transportType().indexOf('webusb') >= 0;
+        if (list.length === 1 && !isWebUsb) {
+            uiPromise.resolve({
+                type: events_2.UI.RECEIVE_DEVICE,
+                payload: { device: list[0] },
+            });
+            removeUiPromise(uiPromise);
+        }
+        else {
+            postMessage((0, events_2.createUiMessage)(events_2.UI.SELECT_DEVICE, {
+                webusb: isWebUsb,
+                devices: list,
+            }));
+        }
+    }
+    if (interruptDevice) {
+        const { path } = interruptDevice;
+        let shouldClosePopup = false;
+        _uiPromises.forEach(p => {
+            if (p.data && p.data.getDevicePath() === path) {
+                if (p.id === events_2.DEVICE.DISCONNECT) {
+                    p.resolve({ type: events_2.DEVICE.DISCONNECT });
+                }
+                shouldClosePopup = true;
+            }
+        });
+        if (_preferredDevice && _preferredDevice.path === path) {
+            _preferredDevice = undefined;
+        }
+        if (shouldClosePopup) {
+            closePopup();
+            cleanup();
+        }
+    }
+};
+const initDeviceList = async (settings) => {
+    try {
+        _deviceList = new DeviceList_1.DeviceList();
+        _deviceList.on(events_2.DEVICE.CONNECT, device => {
+            handleDeviceSelectionChanges();
+            postMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CONNECT, device));
+        });
+        _deviceList.on(events_2.DEVICE.CONNECT_UNACQUIRED, device => {
+            handleDeviceSelectionChanges();
+            postMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CONNECT_UNACQUIRED, device));
+        });
+        _deviceList.on(events_2.DEVICE.DISCONNECT, device => {
+            handleDeviceSelectionChanges(device);
+            postMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.DISCONNECT, device));
+        });
+        _deviceList.on(events_2.DEVICE.CHANGED, device => {
+            postMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CHANGED, device));
+        });
+        _deviceList.on(events_2.TRANSPORT.ERROR, async (error) => {
+            _log.warn('TRANSPORT.ERROR', error);
+            if (_deviceList) {
+                _deviceList.disconnectDevices();
+                _deviceList.dispose();
+            }
+            _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);
+            }
+        });
+        _deviceList.on(events_2.TRANSPORT.START, transportType => postMessage((0, events_2.createTransportMessage)(events_2.TRANSPORT.START, transportType)));
+        await _deviceList.init();
+        if (_deviceList) {
+            await _deviceList.waitForTransportFirstEvent();
+        }
+    }
+    catch (error) {
+        _deviceList = undefined;
+        postMessage((0, events_2.createTransportMessage)(events_2.TRANSPORT.ERROR, { error }));
+        if (!settings.transportReconnect) {
+            throw error;
+        }
+        else {
+            await (0, promiseUtils_1.resolveAfter)(3000, null);
+            await initDeviceList(settings);
+        }
+    }
+};
+class Core extends events_1.default {
+    handleMessage(message, isTrustedOrigin) {
+        (0, exports.handleMessage)(message, isTrustedOrigin);
+    }
+    dispose() {
+        if (_deviceList) {
+            _deviceList.dispose();
+        }
+        (0, BlockchainLink_1.dispose)();
+        this.removeAllListeners();
+    }
+    getCurrentMethod() {
+        return _callMethods;
+    }
+    getTransportInfo() {
+        if (_deviceList) {
+            return _deviceList.getTransportInfo();
+        }
+        return {
+            type: '',
+            version: '',
+            outdated: true,
+        };
+    }
+}
+exports.Core = Core;
+const initCore = () => {
+    _core = new Core();
+    return _core;
+};
+exports.initCore = initCore;
+const init = async (settings) => {
+    try {
+        await DataManager_1.DataManager.load(settings);
+        (0, debug_1.enableLog)(DataManager_1.DataManager.getSettings('debug'));
+        (0, exports.initCore)();
+        _interactionTimeout = new interactionTimeout_1.InteractionTimeout(settings.popup ? settings.interactionTimeout : 0);
+        return _core;
+    }
+    catch (error) {
+        _log.error('init', error);
+        throw error;
+    }
+};
+exports.init = init;
+const initTransport = async (settings) => {
+    try {
+        if (!settings.transportReconnect) {
+            await initDeviceList(settings);
+        }
+        else {
+            initDeviceList(settings);
+        }
+    }
+    catch (error) {
+        _log.error('initTransport', error);
+        throw error;
+    }
+};
+exports.initTransport = initTransport;
+const disableWebUSBTransport = async () => {
+    if (!_deviceList)
+        return;
+    if (_deviceList.transportType() !== 'WebUsbPlugin')
+        return;
+    const settings = DataManager_1.DataManager.getSettings();
+    settings.webusb = false;
+    try {
+        _deviceList.dispose();
+        await initDeviceList(settings);
+    }
+    catch (error) {
+    }
+};
+//# sourceMappingURL=index.js.map

package/lib/core/method.d.ts

@@ -0,0 +1,6 @@
+import * as Methods from '../api';
+import type { IFrameCallMessage } from '../events';
+export declare const getMethod: (message: IFrameCallMessage & {
+    id?: number;
+}) => Methods.applyFlags | Methods.applySettings | Methods.authorizeCoinJoin | Methods.backupDevice | Methods.binanceGetAddress | Methods.binanceGetPublicKey | Methods.binanceSignTransaction | Methods.blockchainDisconnect | Methods.blockchainEstimateFee | Methods.blockchainGetAccountBalanceHistory | Methods.blockchainGetCurrentFiatRates | Methods.blockchainGetFiatRatesForTimestamps | Methods.blockchainGetTransactions | Methods.blockchainSetCustomBackend | Methods.blockchainSubscribe | Methods.blockchainSubscribeFiatRates | Methods.blockchainUnsubscribe | Methods.blockchainUnsubscribeFiatRates | Methods.cardanoGetAddress | Methods.cardanoGetNativeScriptHash | Methods.cardanoGetPublicKey | Methods.cardanoSignTransaction | Methods.changePin | Methods.cipherKeyValue | Methods.composeTransaction | Methods.customMessage | Methods.eosGetPublicKey | Methods.eosSignTransaction | Methods.ethereumGetAddress | Methods.ethereumGetPublicKey | Methods.ethereumSignMessage | Methods.ethereumSignTransaction | Methods.ethereumSignTypedData | Methods.ethereumVerifyMessage | Methods.firmwareUpdate | Methods.getAccountInfo | Methods.getAddress | Methods.getCoinInfo | Methods.getDeviceState | Methods.getFeatures | Methods.getOwnershipId | Methods.getOwnershipProof | Methods.getPublicKey | Methods.getSettings | Methods.nemGetAddress | Methods.nemSignTransaction | Methods.pushTransaction | Methods.rebootToBootloader | Methods.recoveryDevice | Methods.requestLogin | Methods.resetDevice | Methods.rippleGetAddress | Methods.rippleSignTransaction | Methods.setProxy | Methods.signMessage | Methods.signTransaction | Methods.stellarGetAddress | Methods.stellarSignTransaction | Methods.tezosGetAddress | Methods.tezosGetPublicKey | Methods.tezosSignTransaction | Methods.verifyMessage | Methods.wipeDevice;
+//# sourceMappingURL=method.d.ts.map

package/lib/core/method.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMethod = void 0;
+const tslib_1 = require("tslib");
+const Methods = (0, tslib_1.__importStar)(require("../api"));
+const errors_1 = require("../constants/errors");
+const getMethod = (message) => {
+    const { method } = message.payload;
+    if (typeof method !== 'string') {
+        throw (0, errors_1.TypedError)('Method_InvalidParameter', 'Message method is not set');
+    }
+    const MethodConstructor = Methods[method];
+    if (MethodConstructor) {
+        return new MethodConstructor(message);
+    }
+    throw (0, errors_1.TypedError)('Method_InvalidParameter', `Method ${method} not found`);
+};
+exports.getMethod = getMethod;
+//# sourceMappingURL=method.js.map