@trezor/connect 9.0.11 → 9.1.2

package/lib/device/DescriptorStream.d.ts

@@ -1,28 +0,0 @@
-/// <reference types="node" />
-import EventEmitter from 'events';
-import type { Transport, TrezorDeviceInfoWithSession as DeviceDescriptor } from '@trezor/transport';
-export type DeviceDescriptorDiff = {
-    didUpdate: boolean;
-    connected: DeviceDescriptor[];
-    disconnected: DeviceDescriptor[];
-    changedSessions: DeviceDescriptor[];
-    changedDebugSessions: DeviceDescriptor[];
-    acquired: DeviceDescriptor[];
-    debugAcquired: DeviceDescriptor[];
-    released: DeviceDescriptor[];
-    debugReleased: DeviceDescriptor[];
-    descriptors: DeviceDescriptor[];
-};
-export declare class DescriptorStream extends EventEmitter {
-    transport: Transport;
-    listening: boolean;
-    listenTimestamp: number;
-    current: DeviceDescriptor[] | null;
-    upcoming: DeviceDescriptor[];
-    constructor(transport: Transport);
-    listen(): Promise<void>;
-    enumerate(): Promise<void>;
-    stop(): void;
-    _reportChanges(): void;
-}
-//# sourceMappingURL=DescriptorStream.d.ts.map

package/lib/device/DescriptorStream.js

@@ -1,139 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DescriptorStream = void 0;
-const tslib_1 = require("tslib");
-const events_1 = tslib_1.__importDefault(require("events"));
-const transport_1 = require("../events/transport");
-const device_1 = require("../events/device");
-const debug_1 = require("../utils/debug");
-const DataManager_1 = require("../data/DataManager");
-const promiseUtils_1 = require("../utils/promiseUtils");
-const logger = (0, debug_1.initLog)('DescriptorStream');
-const getDiff = (current, descriptors) => {
-    const connected = descriptors.filter(d => current.find(x => x.path === d.path) === undefined);
-    const disconnected = current.filter(d => descriptors.find(x => x.path === d.path) === undefined);
-    const changedSessions = descriptors.filter(d => {
-        const currentDescriptor = current.find(x => x.path === d.path);
-        if (currentDescriptor) {
-            return currentDescriptor.session !== d.session;
-        }
-        return false;
-    });
-    const acquired = changedSessions.filter(d => typeof d.session === 'string');
-    const released = changedSessions.filter(d => typeof d.session !== 'string');
-    const changedDebugSessions = descriptors.filter(d => {
-        const currentDescriptor = current.find(x => x.path === d.path);
-        if (currentDescriptor) {
-            return currentDescriptor.debugSession !== d.debugSession;
-        }
-        return false;
-    });
-    const debugAcquired = changedSessions.filter(d => typeof d.debugSession === 'string');
-    const debugReleased = changedSessions.filter(d => typeof d.debugSession !== 'string');
-    const didUpdate = connected.length +
-        disconnected.length +
-        changedSessions.length +
-        changedDebugSessions.length >
-        0;
-    return {
-        connected,
-        disconnected,
-        changedSessions,
-        acquired,
-        released,
-        changedDebugSessions,
-        debugAcquired,
-        debugReleased,
-        didUpdate,
-        descriptors,
-    };
-};
-class DescriptorStream extends events_1.default {
-    constructor(transport) {
-        super();
-        this.listening = false;
-        this.listenTimestamp = 0;
-        this.current = null;
-        this.upcoming = [];
-        this.transport = transport;
-    }
-    async listen() {
-        const waitForEvent = this.current !== null;
-        const current = this.current || [];
-        this.listening = true;
-        let descriptors;
-        try {
-            logger.debug('Start listening', current);
-            this.listenTimestamp = new Date().getTime();
-            descriptors = waitForEvent
-                ? await this.transport.listen(current)
-                : await this.transport.enumerate();
-            if (this.listening && !waitForEvent) {
-                if (descriptors.length > 0 && DataManager_1.DataManager.getSettings('pendingTransportEvent')) {
-                    this.emit(transport_1.TRANSPORT.START_PENDING, descriptors.length);
-                }
-                else {
-                    this.emit(transport_1.TRANSPORT.START);
-                }
-            }
-            if (!this.listening)
-                return;
-            this.upcoming = descriptors;
-            logger.debug('Listen result', descriptors);
-            this._reportChanges();
-            if (this.listening)
-                this.listen();
-        }
-        catch (error) {
-            const time = new Date().getTime() - this.listenTimestamp;
-            logger.debug('Listen error', 'timestamp', time, typeof error);
-            if (time > 1100) {
-                await (0, promiseUtils_1.resolveAfter)(1000, null).promise;
-                if (this.listening)
-                    this.listen();
-            }
-            else {
-                logger.warn('Transport error');
-                this.emit(transport_1.TRANSPORT.ERROR, error);
-            }
-        }
-    }
-    async enumerate() {
-        if (!this.listening)
-            return;
-        try {
-            this.upcoming = await this.transport.enumerate();
-            this._reportChanges();
-        }
-        catch (error) {
-        }
-    }
-    stop() {
-        this.listening = false;
-        this.removeAllListeners();
-    }
-    _reportChanges() {
-        const diff = getDiff(this.current || [], this.upcoming);
-        this.current = this.upcoming;
-        if (diff.didUpdate && this.listening) {
-            diff.connected.forEach(d => {
-                this.emit(device_1.DEVICE.CONNECT, d);
-            });
-            diff.disconnected.forEach(d => {
-                this.emit(device_1.DEVICE.DISCONNECT, d);
-            });
-            diff.acquired.forEach(d => {
-                this.emit(device_1.DEVICE.ACQUIRED, d);
-            });
-            diff.released.forEach(d => {
-                this.emit(device_1.DEVICE.RELEASED, d);
-            });
-            diff.changedSessions.forEach(d => {
-                this.emit(device_1.DEVICE.CHANGED, d);
-            });
-            this.emit(transport_1.TRANSPORT.UPDATE, diff);
-        }
-    }
-}
-exports.DescriptorStream = DescriptorStream;
-//# sourceMappingURL=DescriptorStream.js.map

package/lib/utils/objectUtils.d.ts

@@ -1,10 +0,0 @@
-export declare function clone<T>(obj: T): T;
-export declare function entries<T>(obj: {
-    [key: string]: T;
-}): Array<[string, T]>;
-export declare function deepClone(_obj: any, _hash?: any): void;
-export declare function snapshot(obj: any): any;
-export declare function objectValues<X>(object: {
-    [key: string]: X;
-}): X[];
-//# sourceMappingURL=objectUtils.d.ts.map

package/lib/utils/objectUtils.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.objectValues = exports.snapshot = exports.deepClone = exports.entries = exports.clone = void 0;
-function clone(obj) {
-    const jsonString = JSON.stringify(obj);
-    if (jsonString === undefined) {
-        return obj;
-    }
-    return JSON.parse(jsonString);
-}
-exports.clone = clone;
-function entries(obj) {
-    const keys = Object.keys(obj);
-    return keys.map(key => [key, obj[key]]);
-}
-exports.entries = entries;
-function deepClone(_obj, _hash = new WeakMap()) {
-}
-exports.deepClone = deepClone;
-function snapshot(obj) {
-    if (obj == null || typeof obj !== 'object') {
-        return obj;
-    }
-    const temp = new obj.constructor();
-    Object.keys(temp).forEach(key => {
-        if (Object.prototype.hasOwnProperty.call(obj, key)) {
-            temp[key] = snapshot(obj[key]);
-        }
-    });
-    return temp;
-}
-exports.snapshot = snapshot;
-function objectValues(object) {
-    return Object.keys(object).map(key => object[key]);
-}
-exports.objectValues = objectValues;
-//# sourceMappingURL=objectUtils.js.map

package/lib/workers/RNUsbPlugin.d.ts

@@ -1,31 +0,0 @@
-type TrezorDeviceInfoDebug = {
-    path: string;
-    debug: boolean;
-};
-interface TrezorTransport {
-    enumerate(): Promise<TrezorDeviceInfoDebug[]>;
-    acquire(path: string, debugLink: boolean): Promise<void>;
-    release(path: string, debugLink: boolean, closePort: boolean): Promise<void>;
-    write(path: string, debugLink: boolean, data: string): Promise<void>;
-    read(path: string, debugLink: boolean): Promise<{
-        data: string;
-    }>;
-}
-export declare class ReactNativePlugin {
-    name: string;
-    version: string;
-    debug: boolean;
-    allowsWriteAndEnumerate: boolean;
-    requestNeeded: boolean;
-    usb: TrezorTransport;
-    constructor();
-    init(debug?: boolean): Promise<void>;
-    enumerate(): Promise<TrezorDeviceInfoDebug[]>;
-    send(path: string, data: ArrayBuffer, debugLink: boolean): Promise<void>;
-    receive(path: string, debugLink: boolean): Promise<ArrayBuffer>;
-    connect(path: string, debugLink: boolean): Promise<void>;
-    disconnect(path: string, debugLink: boolean, last: boolean): Promise<void>;
-    requestDevice(): any;
-}
-export {};
-//# sourceMappingURL=RNUsbPlugin.d.ts.map

package/lib/workers/RNUsbPlugin.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReactNativePlugin = void 0;
-const react_native_1 = require("react-native");
-const bufferToHex = (buffer) => Array.prototype.map.call(new Uint8Array(buffer), x => `00${x.toString(16)}`.slice(-2)).join('');
-const toArrayBuffer = (buffer) => {
-    const ab = new ArrayBuffer(buffer.length);
-    const view = new Uint8Array(ab);
-    const len = buffer.length;
-    for (let i = 0; i < len; ++i) {
-        view[i] = buffer[i];
-    }
-    return ab;
-};
-class ReactNativePlugin {
-    constructor() {
-        this.name = 'ReactNativePlugin';
-        this.version = '1.0.0';
-        this.debug = false;
-        this.allowsWriteAndEnumerate = true;
-        this.requestNeeded = false;
-        this.usb = react_native_1.NativeModules.TrezorTransport;
-    }
-    init(debug) {
-        this.debug = !!debug;
-        if (!this.usb) {
-            throw new Error('ReactNative plugin is not available');
-        }
-        return Promise.resolve();
-    }
-    enumerate() {
-        return this.usb.enumerate();
-    }
-    send(path, data, debugLink) {
-        const dataHex = bufferToHex(data);
-        return this.usb.write(path, debugLink, dataHex);
-    }
-    async receive(path, debugLink) {
-        const { data } = await this.usb.read(path, debugLink);
-        return toArrayBuffer(Buffer.from(data, 'hex'));
-    }
-    async connect(path, debugLink) {
-        for (let i = 0; i < 5; i++) {
-            if (i > 0) {
-                await new Promise(resolve => setTimeout(resolve, i * 200));
-            }
-            try {
-                await this.usb.acquire(path, debugLink);
-                return;
-            }
-            catch (e) {
-                if (i === 4) {
-                    throw e;
-                }
-            }
-        }
-    }
-    disconnect(path, debugLink, last) {
-        return this.usb.release(path, debugLink, last);
-    }
-    requestDevice() {
-    }
-}
-exports.ReactNativePlugin = ReactNativePlugin;
-//# sourceMappingURL=RNUsbPlugin.js.map