@trezor/connect 9.0.0-beta.1

package/lib/device/DeviceList.js

@@ -0,0 +1,411 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDeviceList = exports.DeviceList = void 0;
+const tslib_1 = require("tslib");
+const events_1 = (0, tslib_1.__importDefault)(require("events"));
+const transport_1 = (0, tslib_1.__importDefault)(require("@trezor/transport"));
+const cross_fetch_1 = (0, tslib_1.__importDefault)(require("cross-fetch"));
+const constants_1 = require("../constants");
+const events_2 = require("../events");
+const DescriptorStream_1 = require("./DescriptorStream");
+const Device_1 = require("./Device");
+const DataManager_1 = require("../data/DataManager");
+const transportInfo_1 = require("../data/transportInfo");
+const debug_1 = require("../utils/debug");
+const promiseUtils_1 = require("../utils/promiseUtils");
+const workers_1 = require("../workers/workers");
+const AbortController_1 = require("./AbortController");
+const { BridgeV2, Fallback } = transport_1.default;
+const _log = (0, debug_1.initLog)('DeviceList');
+class DeviceList extends events_1.default {
+    constructor() {
+        super();
+        this.devices = {};
+        this.creatingDevicesDescriptors = {};
+        this.hasCustomMessages = false;
+        this.transportStartPending = 0;
+        this.penalizedDevices = {};
+        const { env, webusb } = DataManager_1.DataManager.settings;
+        const transports = [];
+        if (env === 'react-native' && typeof workers_1.ReactNativeUsbPlugin !== 'undefined') {
+            transports.push((0, workers_1.ReactNativeUsbPlugin)());
+        }
+        else {
+            const bridgeLatestVersion = (0, transportInfo_1.getBridgeInfo)().version.join('.');
+            const bridge = new BridgeV2(undefined, undefined);
+            bridge.setBridgeLatestVersion(bridgeLatestVersion);
+            this.fetchController = (0, AbortController_1.getAbortController)();
+            const { signal } = this.fetchController;
+            const fetchWithSignal = (args, options = {}) => (0, cross_fetch_1.default)(args, { ...options, signal });
+            BridgeV2.setFetch(fetchWithSignal, typeof window === 'undefined');
+            transports.push(bridge);
+        }
+        if (webusb && typeof workers_1.WebUsbPlugin !== 'undefined') {
+            transports.push((0, workers_1.WebUsbPlugin)());
+        }
+        this.transport = new Fallback(transports);
+        this.defaultMessages = DataManager_1.DataManager.getProtobufMessages();
+        this.currentMessages = this.defaultMessages;
+    }
+    async init() {
+        const { transport } = this;
+        try {
+            _log.debug('Initializing transports');
+            await transport.init(_log.enabled);
+            _log.debug('Configuring transports');
+            await transport.configure(JSON.stringify(this.defaultMessages));
+            _log.debug('Configuring transports done');
+            const { activeName } = transport;
+            if (activeName === 'LowlevelTransportWithSharedConnections') {
+                this.transportPlugin = transport.activeTransport.plugin;
+            }
+            await this._initStream();
+            this.on(events_2.DEVICE.CONNECT, this.resolveTransportEvent.bind(this));
+            this.on(events_2.DEVICE.CONNECT_UNACQUIRED, this.resolveTransportEvent.bind(this));
+        }
+        catch (error) {
+            this.emit(events_2.TRANSPORT.ERROR, error);
+        }
+    }
+    async reconfigure(messages, custom) {
+        if (Array.isArray(messages)) {
+            messages = DataManager_1.DataManager.getProtobufMessages(messages);
+        }
+        if (this.currentMessages === messages || !messages)
+            return;
+        try {
+            await this.transport.configure(JSON.stringify(messages));
+            this.currentMessages = messages;
+            this.hasCustomMessages = typeof custom === 'boolean' ? custom : false;
+        }
+        catch (error) {
+            throw constants_1.ERRORS.TypedError('Transport_InvalidProtobuf', error.message);
+        }
+    }
+    async restoreMessages() {
+        if (!this.hasCustomMessages)
+            return;
+        try {
+            await this.transport.configure(JSON.stringify(this.defaultMessages));
+            this.hasCustomMessages = false;
+        }
+        catch (error) {
+            throw constants_1.ERRORS.TypedError('Transport_InvalidProtobuf', error.message);
+        }
+    }
+    resolveTransportEvent() {
+        this.transportStartPending--;
+        if (this.transportStartPending === 0) {
+            this.stream.emit(events_2.TRANSPORT.START);
+        }
+    }
+    async waitForTransportFirstEvent() {
+        await new Promise(resolve => {
+            const handler = () => {
+                this.removeListener(events_2.TRANSPORT.START, handler);
+                this.removeListener(events_2.TRANSPORT.ERROR, handler);
+                resolve();
+            };
+            this.on(events_2.TRANSPORT.START, handler);
+            this.on(events_2.TRANSPORT.ERROR, handler);
+        });
+    }
+    _initStream() {
+        const stream = new DescriptorStream_1.DescriptorStream(this.transport);
+        stream.on(events_2.TRANSPORT.START_PENDING, (pending) => {
+            this.transportStartPending = pending;
+        });
+        stream.on(events_2.TRANSPORT.START, () => {
+            this.emit(events_2.TRANSPORT.START, this.getTransportInfo());
+        });
+        stream.on(events_2.TRANSPORT.UPDATE, (diff) => {
+            new DiffHandler(this, diff).handle();
+        });
+        stream.on(events_2.TRANSPORT.ERROR, error => {
+            this.emit(events_2.TRANSPORT.ERROR, error);
+            stream.stop();
+        });
+        stream.listen();
+        this.stream = stream;
+        if (this.transportPlugin && this.transportPlugin.name === 'WebUsbPlugin') {
+            const { unreadableHidDeviceChange } = this.transportPlugin;
+            const UNREADABLE_PATH = 'unreadable';
+            unreadableHidDeviceChange.on('change', () => {
+                if (this.transportPlugin && this.transportPlugin.unreadableHidDevice) {
+                    const device = this._createUnreadableDevice({
+                        path: UNREADABLE_PATH,
+                        session: null,
+                        debugSession: null,
+                        debug: false,
+                    }, 'HID_DEVICE');
+                    this.devices[UNREADABLE_PATH] = device;
+                    this.emit(events_2.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
+                }
+                else {
+                    const device = this.devices[UNREADABLE_PATH];
+                    delete this.devices[UNREADABLE_PATH];
+                    this.emit(events_2.DEVICE.DISCONNECT, device.toMessageObject());
+                }
+            });
+        }
+        this.emit(events_2.TRANSPORT.STREAM, stream);
+    }
+    async _createAndSaveDevice(descriptor) {
+        _log.debug('Creating Device', descriptor);
+        await new CreateDeviceHandler(descriptor, this).handle();
+    }
+    _createUnacquiredDevice(descriptor) {
+        _log.debug('Creating Unacquired Device', descriptor);
+        const device = Device_1.Device.createUnacquired(this.transport, descriptor);
+        device.once(events_2.DEVICE.ACQUIRED, () => {
+            this.emit(events_2.DEVICE.CONNECT, device.toMessageObject());
+        });
+        return device;
+    }
+    _createUnreadableDevice(descriptor, unreadableError) {
+        _log.debug('Creating Unreadable Device', descriptor, unreadableError);
+        return Device_1.Device.createUnacquired(this.transport, descriptor, unreadableError);
+    }
+    getDevice(path) {
+        return this.devices[path];
+    }
+    getFirstDevicePath() {
+        return this.asArray()[0].path;
+    }
+    asArray() {
+        return this.allDevices().map(device => device.toMessageObject());
+    }
+    allDevices() {
+        return Object.keys(this.devices).map(key => this.devices[key]);
+    }
+    length() {
+        return this.asArray().length;
+    }
+    transportType() {
+        const { transport, transportPlugin } = this;
+        const { activeName } = transport;
+        if (activeName === 'BridgeTransport') {
+            return 'bridge';
+        }
+        if (transportPlugin) {
+            return transportPlugin.name;
+        }
+        return transport.name;
+    }
+    getTransportInfo() {
+        return {
+            type: this.transportType(),
+            version: this.transport.version,
+            outdated: this.transport.isOutdated,
+        };
+    }
+    dispose() {
+        this.removeAllListeners();
+        if (this.stream) {
+            this.stream.stop();
+        }
+        if (this.transport) {
+            this.transport.stop();
+        }
+        if (this.fetchController) {
+            this.fetchController.abort();
+            this.fetchController = null;
+        }
+        this.allDevices().forEach(device => device.dispose());
+    }
+    disconnectDevices() {
+        this.allDevices().forEach(device => {
+            this.emit(events_2.DEVICE.DISCONNECT, device.toMessageObject());
+        });
+    }
+    enumerate() {
+        this.stream.enumerate();
+        if (!this.stream.current)
+            return;
+        this.stream.current.forEach(descriptor => {
+            const path = descriptor.path.toString();
+            const device = this.devices[path];
+            if (device) {
+                device.updateDescriptor(descriptor);
+            }
+        });
+    }
+    addAuthPenalty(device) {
+        if (!device.isInitialized() || device.isBootloader() || !device.features.device_id)
+            return;
+        const deviceID = device.features.device_id;
+        const penalty = this.penalizedDevices[deviceID]
+            ? this.penalizedDevices[deviceID] + 500
+            : 2000;
+        this.penalizedDevices[deviceID] = Math.min(penalty, 5000);
+    }
+    getAuthPenalty() {
+        const { penalizedDevices } = this;
+        return Object.keys(penalizedDevices).reduce((penalty, key) => Math.max(penalty, penalizedDevices[key]), 0);
+    }
+    removeAuthPenalty(device) {
+        if (!device.isInitialized() || device.isBootloader() || !device.features.device_id)
+            return;
+        const deviceID = device.features.device_id;
+        delete this.penalizedDevices[deviceID];
+    }
+}
+exports.DeviceList = DeviceList;
+const getDeviceList = async () => {
+    const list = new DeviceList();
+    await list.init();
+    return list;
+};
+exports.getDeviceList = getDeviceList;
+class CreateDeviceHandler {
+    constructor(descriptor, list) {
+        this.descriptor = descriptor;
+        this.list = list;
+        this.path = descriptor.path.toString();
+    }
+    async handle() {
+        this.list.creatingDevicesDescriptors[this.path] = this.descriptor;
+        try {
+            await this._takeAndCreateDevice();
+        }
+        catch (error) {
+            _log.debug('Cannot create device', error);
+            if (error.code === 'Device_NotFound') {
+            }
+            else if (error.message === constants_1.ERRORS.WRONG_PREVIOUS_SESSION_ERROR_MESSAGE ||
+                error.toString() === constants_1.ERRORS.WEBUSB_ERROR_MESSAGE) {
+                this.list.enumerate();
+                this._handleUsedElsewhere();
+            }
+            else if (error.message.indexOf(constants_1.ERRORS.LIBUSB_ERROR_MESSAGE) >= 0) {
+                const device = this.list._createUnreadableDevice(this.list.creatingDevicesDescriptors[this.path], error.message);
+                this.list.devices[this.path] = device;
+                this.list.emit(events_2.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
+            }
+            else if (error.code === 'Device_InitializeFailed') {
+                this._handleUsedElsewhere();
+            }
+            else if (error.code === 'Device_UsedElsewhere') {
+                this._handleUsedElsewhere();
+            }
+            else {
+                await (0, promiseUtils_1.resolveAfter)(501, null);
+                await this.handle();
+            }
+        }
+        delete this.list.creatingDevicesDescriptors[this.path];
+    }
+    async _takeAndCreateDevice() {
+        const device = Device_1.Device.fromDescriptor(this.list.transport, this.descriptor);
+        this.list.devices[this.path] = device;
+        await device.run();
+        this.list.emit(events_2.DEVICE.CONNECT, device.toMessageObject());
+    }
+    _handleUsedElsewhere() {
+        const device = this.list._createUnacquiredDevice(this.list.creatingDevicesDescriptors[this.path]);
+        this.list.devices[this.path] = device;
+        this.list.emit(events_2.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
+    }
+}
+class DiffHandler {
+    constructor(list, diff) {
+        this.list = list;
+        this.diff = diff;
+    }
+    handle() {
+        _log.debug('Update DescriptorStream', this.diff);
+        this._createConnectedDevices();
+        this._createReleasedDevices();
+        this._signalAcquiredDevices();
+        this._updateDescriptors();
+        this._emitEvents();
+        this._disconnectDevices();
+    }
+    _updateDescriptors() {
+        this.diff.descriptors.forEach((descriptor) => {
+            const path = descriptor.path.toString();
+            const device = this.list.devices[path];
+            if (device) {
+                device.updateDescriptor(descriptor);
+            }
+        });
+    }
+    _emitEvents() {
+        const events = [
+            {
+                d: this.diff.changedSessions,
+                e: events_2.DEVICE.CHANGED,
+            },
+            {
+                d: this.diff.acquired,
+                e: events_2.DEVICE.ACQUIRED,
+            },
+            {
+                d: this.diff.released,
+                e: events_2.DEVICE.RELEASED,
+            },
+        ];
+        events.forEach(({ d, e }) => {
+            d.forEach(descriptor => {
+                const path = descriptor.path.toString();
+                const device = this.list.devices[path];
+                _log.debug('Event', e, device);
+                if (device) {
+                    this.list.emit(e, device.toMessageObject());
+                }
+            });
+        });
+    }
+    _createConnectedDevices() {
+        this.diff.connected.forEach(async (descriptor) => {
+            const path = descriptor.path.toString();
+            const priority = DataManager_1.DataManager.getSettings('priority');
+            const penalty = this.list.getAuthPenalty();
+            _log.debug('Connected', priority, penalty, descriptor.session, this.list.devices);
+            if (priority || penalty) {
+                await (0, promiseUtils_1.resolveAfter)(501 + penalty + 100 * priority, null);
+            }
+            if (descriptor.session == null) {
+                await this.list._createAndSaveDevice(descriptor);
+            }
+            else {
+                const device = await this.list._createUnacquiredDevice(descriptor);
+                this.list.devices[path] = device;
+                this.list.emit(events_2.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
+            }
+        });
+    }
+    _signalAcquiredDevices() {
+        this.diff.acquired.forEach(descriptor => {
+            const path = descriptor.path.toString();
+            if (this.list.creatingDevicesDescriptors[path]) {
+                this.list.creatingDevicesDescriptors[path] = descriptor;
+            }
+        });
+    }
+    _createReleasedDevices() {
+        this.diff.released.forEach(async (descriptor) => {
+            const path = descriptor.path.toString();
+            const device = this.list.devices[path];
+            if (device) {
+                if (device.isUnacquired() && !device.isInconsistent()) {
+                    await (0, promiseUtils_1.resolveAfter)(501, null);
+                    _log.debug('Create device from unacquired', device);
+                    await this.list._createAndSaveDevice(descriptor);
+                }
+            }
+        });
+    }
+    _disconnectDevices() {
+        this.diff.disconnected.forEach(descriptor => {
+            const path = descriptor.path.toString();
+            const device = this.list.devices[path];
+            if (device != null) {
+                device.disconnect();
+                delete this.list.devices[path];
+                this.list.emit(events_2.DEVICE.DISCONNECT, device.toMessageObject());
+            }
+        });
+    }
+}
+//# sourceMappingURL=DeviceList.js.map

package/lib/events/blockchain.d.ts

@@ -0,0 +1,56 @@
+import type { ServerInfo, BlockEvent, FiatRates, NotificationEvent } from '@trezor/blockchain-link';
+import type { CoinInfo } from '../types/coinInfo';
+import type { MessageFactoryFn } from '../types/utils';
+export declare const BLOCKCHAIN_EVENT = "BLOCKCHAIN_EVENT";
+export declare const BLOCKCHAIN: {
+    readonly CONNECT: "blockchain-connect";
+    readonly ERROR: "blockchain-error";
+    readonly BLOCK: "blockchain-block";
+    readonly NOTIFICATION: "blockchain-notification";
+    readonly FIAT_RATES_UPDATE: "fiat-rates-update";
+};
+export interface BlockchainInfo extends ServerInfo {
+    coin: CoinInfo;
+    cleanUrl?: string;
+    misc?: {
+        reserve?: string;
+    };
+}
+export interface BlockchainError {
+    coin: CoinInfo;
+    error: string;
+    code?: string;
+}
+export declare type BlockchainBlock = BlockEvent['payload'] & {
+    coin: CoinInfo;
+};
+export interface BlockchainNotification {
+    coin: CoinInfo;
+    notification: NotificationEvent['payload'];
+}
+export interface BlockchainFiatRatesUpdate {
+    coin: CoinInfo;
+    rates: FiatRates;
+}
+export declare type BlockchainEvent = {
+    type: typeof BLOCKCHAIN.CONNECT;
+    payload: BlockchainInfo;
+} | {
+    type: typeof BLOCKCHAIN.ERROR;
+    payload: BlockchainError;
+} | {
+    type: typeof BLOCKCHAIN.BLOCK;
+    payload: BlockchainBlock;
+} | {
+    type: typeof BLOCKCHAIN.NOTIFICATION;
+    payload: BlockchainNotification;
+} | {
+    type: typeof BLOCKCHAIN.FIAT_RATES_UPDATE;
+    payload: BlockchainFiatRatesUpdate;
+};
+export declare type BlockchainEventMessage = BlockchainEvent & {
+    event: typeof BLOCKCHAIN_EVENT;
+};
+export declare type BlockchainEventListenerFn = (type: typeof BLOCKCHAIN_EVENT, cb: (event: BlockchainEventMessage) => void) => void;
+export declare const createBlockchainMessage: MessageFactoryFn<typeof BLOCKCHAIN_EVENT, BlockchainEvent>;
+//# sourceMappingURL=blockchain.d.ts.map

package/lib/events/blockchain.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBlockchainMessage = exports.BLOCKCHAIN = exports.BLOCKCHAIN_EVENT = void 0;
+exports.BLOCKCHAIN_EVENT = 'BLOCKCHAIN_EVENT';
+exports.BLOCKCHAIN = {
+    CONNECT: 'blockchain-connect',
+    ERROR: 'blockchain-error',
+    BLOCK: 'blockchain-block',
+    NOTIFICATION: 'blockchain-notification',
+    FIAT_RATES_UPDATE: 'fiat-rates-update',
+};
+const createBlockchainMessage = (type, payload) => ({
+    event: exports.BLOCKCHAIN_EVENT,
+    type,
+    payload,
+});
+exports.createBlockchainMessage = createBlockchainMessage;
+//# sourceMappingURL=blockchain.js.map

package/lib/events/call.d.ts

@@ -0,0 +1,41 @@
+import type { IFRAME } from './iframe';
+import type { TrezorConnect } from '../types/api';
+import type { CommonParams } from '../types/params';
+declare type UnwrappedResponse<T> = T extends Promise<infer R> ? R extends {
+    success: true;
+    payload: infer P;
+} ? P : never : void;
+declare type OverloadedMethod<T, E extends Record<string, string>> = T extends {
+    (params: infer P1): infer R1;
+    (params: infer P2): infer R2;
+} ? ((params: P1 & E) => R1) | ((params: P2 & E) => R2) : T extends (...args: infer P) => infer R ? (params: E & P[0]) => R : never;
+declare type UnwrappedMethod<T, M extends Record<string, string>> = T extends () => infer R ? (params: M & CommonParams) => R : OverloadedMethod<T, M>;
+declare type IsMethodCallable<T> = T extends (...args: any[]) => infer R ? R extends Promise<{
+    success: boolean;
+}> ? R : never : never;
+declare type CallApi = {
+    [K in keyof TrezorConnect]: IsMethodCallable<TrezorConnect[K]> extends never ? never : UnwrappedMethod<TrezorConnect[K], {
+        method: K;
+    }>;
+};
+export declare type CallMethodUnion = CallApi[keyof CallApi];
+export declare type CallMethodPayload = Parameters<CallMethodUnion>[0];
+export declare type CallMethodResponse<M extends keyof CallApi> = UnwrappedResponse<ReturnType<CallApi[M]>>;
+export declare type CallMethodAnyResponse = ReturnType<CallMethodUnion>;
+export declare type CallMethod = (params: CallMethodPayload) => Promise<any>;
+export interface IFrameCallMessage {
+    event: typeof IFRAME.CALL;
+    type: typeof IFRAME.CALL;
+    payload: CallMethodPayload;
+}
+export declare const RESPONSE_EVENT = "RESPONSE_EVENT";
+export interface MethodResponseMessage {
+    event: typeof RESPONSE_EVENT;
+    type: typeof RESPONSE_EVENT;
+    id: number;
+    success: boolean;
+    payload: CallMethodResponse<keyof CallApi>;
+}
+export declare const createResponseMessage: (id: number, success: boolean, payload: any) => MethodResponseMessage;
+export {};
+//# sourceMappingURL=call.d.ts.map

package/lib/events/call.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResponseMessage = exports.RESPONSE_EVENT = void 0;
+const errors_1 = require("../constants/errors");
+exports.RESPONSE_EVENT = 'RESPONSE_EVENT';
+const createResponseMessage = (id, success, payload) => ({
+    event: exports.RESPONSE_EVENT,
+    type: exports.RESPONSE_EVENT,
+    id,
+    success,
+    payload: success ? payload : (0, errors_1.serializeError)(payload),
+});
+exports.createResponseMessage = createResponseMessage;
+//# sourceMappingURL=call.js.map

package/lib/events/core.d.ts

@@ -0,0 +1,20 @@
+import type { BlockchainEventMessage } from './blockchain';
+import type { IFrameCallMessage, MethodResponseMessage } from './call';
+import type { DeviceEventMessage } from './device';
+import type { IFrameEventMessage } from './iframe';
+import type { PopupEventMessage } from './popup';
+import type { TransportEventMessage } from './transport';
+import type { UiEventMessage } from './ui-request';
+import type { UiResponseMessage } from './ui-response';
+import type { Unsuccessful } from '../types/params';
+export declare const CORE_EVENT = "CORE_EVENT";
+export declare type CoreMessage = {
+    id?: number;
+    success?: boolean;
+} & (BlockchainEventMessage | DeviceEventMessage | TransportEventMessage | UiEventMessage | UiResponseMessage | IFrameCallMessage | MethodResponseMessage | IFrameEventMessage | PopupEventMessage);
+export declare type PostMessageEvent = MessageEvent<CoreMessage>;
+export declare const parseMessage: (messageData: any) => CoreMessage;
+export declare const createErrorMessage: (error: Error & {
+    code?: string;
+}) => Unsuccessful;
+//# sourceMappingURL=core.d.ts.map

package/lib/events/core.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createErrorMessage = exports.parseMessage = exports.CORE_EVENT = void 0;
+exports.CORE_EVENT = 'CORE_EVENT';
+const parseMessage = (messageData) => {
+    const message = {
+        event: messageData.event,
+        type: messageData.type,
+        payload: messageData.payload,
+    };
+    if (typeof messageData.id === 'number') {
+        message.id = messageData.id;
+    }
+    if (typeof messageData.success === 'boolean') {
+        message.success = messageData.success;
+    }
+    return message;
+};
+exports.parseMessage = parseMessage;
+const createErrorMessage = (error) => ({
+    success: false,
+    payload: {
+        error: error.message,
+        code: error.code,
+    },
+});
+exports.createErrorMessage = createErrorMessage;
+//# sourceMappingURL=core.js.map

package/lib/events/device.d.ts

@@ -0,0 +1,40 @@
+import type { PROTO } from '../constants';
+import type { Device } from '../types/device';
+import type { MessageFactoryFn } from '../types/utils';
+export declare const DEVICE_EVENT = "DEVICE_EVENT";
+export declare const DEVICE: {
+    readonly CONNECT: "device-connect";
+    readonly CONNECT_UNACQUIRED: "device-connect_unacquired";
+    readonly DISCONNECT: "device-disconnect";
+    readonly CHANGED: "device-changed";
+    readonly ACQUIRE: "device-acquire";
+    readonly RELEASE: "device-release";
+    readonly ACQUIRED: "device-acquired";
+    readonly RELEASED: "device-released";
+    readonly USED_ELSEWHERE: "device-used_elsewhere";
+    readonly LOADING: "device-loading";
+    readonly BUTTON: "button";
+    readonly PIN: "pin";
+    readonly PASSPHRASE: "passphrase";
+    readonly PASSPHRASE_ON_DEVICE: "passphrase_on_device";
+    readonly WORD: "word";
+};
+export interface DeviceButtonRequestPayload extends Omit<PROTO.ButtonRequest, 'code'> {
+    code?: PROTO.ButtonRequest['code'] | 'ButtonRequest_FirmwareUpdate';
+}
+export interface DeviceButtonRequest {
+    type: typeof DEVICE.BUTTON;
+    payload: DeviceButtonRequestPayload & {
+        device: Device;
+    };
+}
+export declare type DeviceEvent = {
+    type: typeof DEVICE.CONNECT | typeof DEVICE.CONNECT_UNACQUIRED | typeof DEVICE.CHANGED | typeof DEVICE.DISCONNECT;
+    payload: Device;
+} | DeviceButtonRequest;
+export declare type DeviceEventMessage = DeviceEvent & {
+    event: typeof DEVICE_EVENT;
+};
+export declare type DeviceEventListenerFn = (type: typeof DEVICE_EVENT, cb: (event: DeviceEventMessage) => void) => void;
+export declare const createDeviceMessage: MessageFactoryFn<typeof DEVICE_EVENT, DeviceEvent>;
+//# sourceMappingURL=device.d.ts.map

package/lib/events/device.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeviceMessage = exports.DEVICE = exports.DEVICE_EVENT = void 0;
+exports.DEVICE_EVENT = 'DEVICE_EVENT';
+exports.DEVICE = {
+    CONNECT: 'device-connect',
+    CONNECT_UNACQUIRED: 'device-connect_unacquired',
+    DISCONNECT: 'device-disconnect',
+    CHANGED: 'device-changed',
+    ACQUIRE: 'device-acquire',
+    RELEASE: 'device-release',
+    ACQUIRED: 'device-acquired',
+    RELEASED: 'device-released',
+    USED_ELSEWHERE: 'device-used_elsewhere',
+    LOADING: 'device-loading',
+    BUTTON: 'button',
+    PIN: 'pin',
+    PASSPHRASE: 'passphrase',
+    PASSPHRASE_ON_DEVICE: 'passphrase_on_device',
+    WORD: 'word',
+};
+const createDeviceMessage = (type, payload) => ({
+    event: exports.DEVICE_EVENT,
+    type,
+    payload,
+});
+exports.createDeviceMessage = createDeviceMessage;
+//# sourceMappingURL=device.js.map