@onekeyfe/hd-transport-web-device 1.0.34-alpha.0

package/dist/index.js

@@ -0,0 +1,766 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var transport = require('@onekeyfe/hd-transport');
+var hdShared = require('@onekeyfe/hd-shared');
+var ByteBuffer = require('bytebuffer');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var transport__default = /*#__PURE__*/_interopDefaultLegacy(transport);
+var ByteBuffer__default = /*#__PURE__*/_interopDefaultLegacy(ByteBuffer);
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const { parseConfigure: parseConfigure$1, buildEncodeBuffers, decodeProtocol, receiveOne: receiveOne$1, check: check$1 } = transport__default["default"];
+const CONFIGURATION_ID = 1;
+const INTERFACE_ID = 0;
+const ENDPOINT_ID = 1;
+const PACKET_SIZE = 64;
+const HEADER_LENGTH = 6;
+class WebUsbTransport {
+    constructor() {
+        this.name = 'WebUsbTransport';
+        this.stopped = false;
+        this.configured = false;
+        this.deviceList = [];
+        this.configurationId = CONFIGURATION_ID;
+        this.endpointId = ENDPOINT_ID;
+        this.interfaceId = INTERFACE_ID;
+    }
+    init(logger) {
+        this.Log = logger;
+        const { usb } = navigator;
+        if (!usb) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'WebUSB is not supported by current browsers');
+        }
+        this.usb = usb;
+    }
+    configure(signedData) {
+        const messages = parseConfigure$1(signedData);
+        this.configured = true;
+        this.messages = messages;
+    }
+    promptDeviceAccess() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.usb)
+                return null;
+            try {
+                const device = yield this.usb.requestDevice({ filters: hdShared.ONEKEY_WEBUSB_FILTER });
+                return device;
+            }
+            catch (e) {
+                this.Log.debug('requestDevice error: ', e);
+                return null;
+            }
+        });
+    }
+    enumerate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.getConnectedDevices();
+            return this.deviceList;
+        });
+    }
+    getConnectedDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.usb)
+                return [];
+            const devices = yield this.usb.getDevices();
+            const onekeyDevices = devices.filter(dev => {
+                const isOneKey = hdShared.ONEKEY_WEBUSB_FILTER.some(desc => dev.vendorId === desc.vendorId && dev.productId === desc.productId);
+                const hasSerialNumber = typeof dev.serialNumber === 'string' && dev.serialNumber.length > 0;
+                return isOneKey && hasSerialNumber;
+            });
+            this.deviceList = onekeyDevices.map(device => ({
+                path: device.serialNumber,
+                device,
+            }));
+            return this.deviceList;
+        });
+    }
+    acquire(input) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!input.path)
+                return;
+            try {
+                yield this.connect((_a = input.path) !== null && _a !== void 0 ? _a : '', true);
+                return yield Promise.resolve(input.path);
+            }
+            catch (e) {
+                this.Log.debug('acquire error: ', e);
+                throw e;
+            }
+        });
+    }
+    findDevice(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.deviceList.length === 0) {
+                yield this.getConnectedDevices();
+            }
+            let device = this.deviceList.find(d => d.path === path);
+            if (device == null) {
+                yield this.getConnectedDevices();
+                device = this.deviceList.find(d => d.path === path);
+                if (device == null) {
+                    throw new Error('Action was interrupted.');
+                }
+            }
+            return device.device;
+        });
+    }
+    connect(path, first) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const maxRetries = 5;
+            for (let i = 0; i < maxRetries; i++) {
+                try {
+                    return yield this.connectToDevice(path, first);
+                }
+                catch (e) {
+                    if (i === maxRetries - 1) {
+                        throw e;
+                    }
+                    yield hdShared.wait(i * 200);
+                }
+            }
+        });
+    }
+    connectToDevice(path, first) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = yield this.findDevice(path);
+            yield device.open();
+            if (first) {
+                yield device.selectConfiguration(this.configurationId);
+                try {
+                    yield device.reset();
+                }
+                catch (error) {
+                }
+            }
+            yield device.claimInterface(this.interfaceId);
+        });
+    }
+    post(session, name, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.call(session, name, data);
+        });
+    }
+    call(path, name, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.messages == null) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
+            }
+            const device = yield this.findDevice(path);
+            if (!device) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound);
+            }
+            const { messages } = this;
+            if (transport.LogBlockCommand.has(name)) {
+                this.Log.debug('call-', ' name: ', name);
+            }
+            else {
+                this.Log.debug('call-', ' name: ', name, ' data: ', data);
+            }
+            const encodeBuffers = buildEncodeBuffers(messages, name, data);
+            for (const buffer of encodeBuffers) {
+                const newArray = new Uint8Array(PACKET_SIZE);
+                newArray[0] = 63;
+                newArray.set(new Uint8Array(buffer), 1);
+                if (!device.opened) {
+                    yield this.connect(path, false);
+                }
+                yield device.transferOut(this.endpointId, newArray);
+            }
+            const resData = yield this.receiveData(path);
+            if (typeof resData !== 'string') {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NetworkError, 'Returning data is not string.');
+            }
+            const jsonData = receiveOne$1(messages, resData);
+            return check$1.call(jsonData);
+        });
+    }
+    receiveData(path) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = yield this.findDevice(path);
+            if (!device.opened) {
+                yield this.connect(path, false);
+            }
+            const firstPacket = yield device.transferIn(this.endpointId, PACKET_SIZE);
+            const firstData = (_a = firstPacket.data) === null || _a === void 0 ? void 0 : _a.buffer.slice(1);
+            console.log('receive first packet: ', firstPacket);
+            const { length, typeId, restBuffer } = decodeProtocol.decodeChunked(firstData);
+            console.log('chunk length: ', length);
+            const lengthWithHeader = Number(length + HEADER_LENGTH);
+            const decoded = new ByteBuffer__default["default"](lengthWithHeader);
+            decoded.writeUint16(typeId);
+            decoded.writeUint32(length);
+            if (length) {
+                decoded.append(restBuffer);
+            }
+            console.log('first decoded: ', decoded);
+            while (decoded.offset < lengthWithHeader) {
+                const res = yield device.transferIn(this.endpointId, PACKET_SIZE);
+                if (!res.data) {
+                    throw new Error('no data');
+                }
+                if (res.data.byteLength === 0) {
+                    console.warn('empty data');
+                }
+                const buffer = res.data.buffer.slice(1);
+                if (lengthWithHeader - decoded.offset >= PACKET_SIZE) {
+                    decoded.append(buffer);
+                }
+                else {
+                    decoded.append(buffer.slice(0, lengthWithHeader - decoded.offset));
+                }
+            }
+            decoded.reset();
+            const result = decoded.toBuffer();
+            return Buffer.from(result).toString('hex');
+        });
+    }
+    release(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = yield this.findDevice(path);
+            yield device.releaseInterface(this.interfaceId);
+            yield device.close();
+        });
+    }
+}
+
+const { parseConfigure, buildBuffers, receiveOne, check } = transport__default["default"];
+class ElectronBleTransport {
+    constructor() {
+        this.name = 'ElectronBleTransport';
+        this.configured = false;
+        this.runPromise = null;
+        this.deviceList = [];
+        this.transportCache = {};
+        this.lastLoggedDevices = '';
+    }
+    init(logger, emitter) {
+        this.Log = logger;
+        this.emitter = emitter;
+        if (!navigator.bluetooth) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Web Bluetooth is not supported by current browser');
+        }
+    }
+    configure(signedData) {
+        const messages = parseConfigure(signedData);
+        this.configured = true;
+        this._messages = messages;
+    }
+    listen() { }
+    logDeviceListIfChanged(devices, scenario, additionalInfo) {
+        var _a;
+        const sortedDevices = [...devices].sort((a, b) => a.id.localeCompare(b.id));
+        const deviceListString = JSON.stringify(sortedDevices.map(d => ({ id: d.id, name: d.name })));
+        if (deviceListString !== this.lastLoggedDevices) {
+            const prefix = scenario === 'enumerate'
+                ? '[Transport] Received new devices'
+                : '[Transport] Received devices in acquire';
+            const message = additionalInfo ? `${prefix} (${additionalInfo}):` : `${prefix}:`;
+            (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(message, devices);
+            this.lastLoggedDevices = deviceListString;
+            return true;
+        }
+        return false;
+    }
+    enumerate() {
+        var _a, _b, _c, _d, _e, _f;
+        return __awaiter(this, void 0, void 0, function* () {
+            (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Transport] Starting enumerate');
+            try {
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[Transport] Checking desktopApi:', window.desktopApi);
+                if (!((_c = window.desktopApi) === null || _c === void 0 ? void 0 : _c.onBleSelect)) {
+                    console.error('[Transport] desktopApi.onBleSelect not available');
+                    throw new Error('desktopApi.onBleSelect not available');
+                }
+                (_e = (_d = window.desktopApi) === null || _d === void 0 ? void 0 : _d.clearPreSelect) === null || _e === void 0 ? void 0 : _e.call(_d);
+                const deviceSet = new Set();
+                const devices = [];
+                this.lastLoggedDevices = '';
+                return yield new Promise(resolve => {
+                    var _a, _b;
+                    (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Transport] Setting up device scanning with 3s timeout');
+                    const cleanupAll = () => {
+                        var _a, _b;
+                        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Transport] Cleaning up resources');
+                        clearTimeout(timeoutId);
+                        cleanup === null || cleanup === void 0 ? void 0 : cleanup();
+                        (_b = window.desktopApi) === null || _b === void 0 ? void 0 : _b.stopBleScan();
+                    };
+                    const timeoutId = setTimeout(() => {
+                        var _a;
+                        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Transport] Scan timeout, returning devices:', devices);
+                        cleanupAll();
+                        resolve(devices);
+                    }, 3000);
+                    const cleanup = (_b = window.desktopApi) === null || _b === void 0 ? void 0 : _b.onBleSelect(newDevices => {
+                        this.logDeviceListIfChanged(newDevices, 'enumerate');
+                        newDevices.forEach(device => {
+                            var _a;
+                            const deviceKey = `${device.id}-${device.name}`;
+                            if (!deviceSet.has(deviceKey)) {
+                                deviceSet.add(deviceKey);
+                                devices.push(device);
+                                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Transport] Added new device:', device);
+                            }
+                        });
+                    });
+                    navigator.bluetooth
+                        .requestDevice({
+                        filters: [{ services: [hdShared.ONEKEY_SERVICE_UUID] }],
+                        optionalServices: [hdShared.ONEKEY_SERVICE_UUID],
+                    })
+                        .catch(error => {
+                        var _a;
+                        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Transport] RequestDevice error (expected):', error);
+                    });
+                });
+            }
+            catch (error) {
+                (_f = window.desktopApi) === null || _f === void 0 ? void 0 : _f.stopBleScan();
+                console.error('[Transport] Error in enumerate:', error);
+                throw error;
+            }
+        });
+    }
+    addDisconnectListener(device) {
+        var _a;
+        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Transport] Adding disconnect listener for device:', device.id);
+        device.addEventListener('gattserverdisconnected', () => {
+            var _a, _b;
+            (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Transport] Device disconnected:', device.id);
+            delete this.transportCache[device.id];
+            (_b = this.emitter) === null || _b === void 0 ? void 0 : _b.emit('device-disconnect', {
+                name: device.name,
+                id: device.id,
+                connectId: device.id,
+            });
+        });
+    }
+    _monitorCharacteristic(characteristic, deviceId) {
+        let bufferLength = 0;
+        let buffer = [];
+        const subscription = (event) => {
+            var _a, _b, _c;
+            const { value } = event.target;
+            if (!value)
+                return;
+            (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Transport] Received notification from device:', deviceId, value);
+            try {
+                const data = new Uint8Array(value.buffer);
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[Transport] Received a packet, buffer:', data);
+                if (hdShared.isHeaderChunk(data)) {
+                    const dataView = new DataView(value.buffer);
+                    bufferLength = dataView.getInt32(5, false);
+                    buffer = [...data.subarray(3)];
+                }
+                else {
+                    buffer = buffer.concat([...data]);
+                }
+                if (buffer.length - transport.COMMON_HEADER_SIZE >= bufferLength) {
+                    const completeBuffer = new Uint8Array(buffer);
+                    (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[Transport] Received complete packet, resolving Promise');
+                    bufferLength = 0;
+                    buffer = [];
+                    const hexString = Array.from(completeBuffer)
+                        .map(b => b.toString(16).padStart(2, '0'))
+                        .join('');
+                    if (this.runPromise) {
+                        this.runPromise.resolve(hexString);
+                    }
+                }
+            }
+            catch (error) {
+                console.error('[Transport] Monitor data error:', error);
+                if (this.runPromise) {
+                    this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError));
+                }
+            }
+        };
+        characteristic.addEventListener('characteristicvaluechanged', subscription);
+        return subscription;
+    }
+    findDevice(id) {
+        return this.deviceList.find(d => d.id === id);
+    }
+    acquire(input) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { uuid, forceCleanRunPromise } = input;
+            if (!uuid) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleRequiredUUID);
+            }
+            (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Transport] Acquiring device:', uuid);
+            this.lastLoggedDevices = '';
+            const existingTransport = this.transportCache[uuid];
+            if (existingTransport) {
+                const { server, device } = existingTransport;
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[Transport] Found existing transport, checking connection status');
+                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[Transport] Device GATT connected:', (_d = device.gatt) === null || _d === void 0 ? void 0 : _d.connected);
+                (_e = this.Log) === null || _e === void 0 ? void 0 : _e.debug('[Transport] Server connected:', server === null || server === void 0 ? void 0 : server.connected);
+                if (!((_f = device.gatt) === null || _f === void 0 ? void 0 : _f.connected) || !(server === null || server === void 0 ? void 0 : server.connected)) {
+                    (_g = this.Log) === null || _g === void 0 ? void 0 : _g.debug('[Transport] Connection is stale, cleaning up...');
+                    yield this.release(uuid);
+                }
+                else {
+                    (_h = this.Log) === null || _h === void 0 ? void 0 : _h.debug('[Transport] Connection is still active, reusing existing transport');
+                    return { uuid, path: uuid };
+                }
+            }
+            if (forceCleanRunPromise && this.runPromise) {
+                this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise));
+                (_j = this.Log) === null || _j === void 0 ? void 0 : _j.debug('[Transport] Force clean Bluetooth run promise:', forceCleanRunPromise);
+            }
+            try {
+                let deviceInfo = this.findDevice(uuid);
+                if (!deviceInfo) {
+                    (_k = this.Log) === null || _k === void 0 ? void 0 : _k.debug('[Transport] Device not found in cache, requesting user to select device');
+                    if (!((_l = window.desktopApi) === null || _l === void 0 ? void 0 : _l.onBleSelect)) {
+                        throw new Error('desktopApi.onBleSelect not available');
+                    }
+                    deviceInfo = yield new Promise((resolve, reject) => {
+                        var _a, _b, _c;
+                        let resolved = false;
+                        let targetDeviceName = null;
+                        (_b = (_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.preSelectDevice) === null || _b === void 0 ? void 0 : _b.call(_a, uuid);
+                        const cleanupAndResolve = (deviceInfo) => {
+                            var _a, _b;
+                            if (resolved)
+                                return;
+                            resolved = true;
+                            cleanup === null || cleanup === void 0 ? void 0 : cleanup();
+                            clearTimeout(timeoutId);
+                            (_b = (_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.clearPreSelect) === null || _b === void 0 ? void 0 : _b.call(_a);
+                            resolve(deviceInfo);
+                        };
+                        const cleanupAndReject = (error) => {
+                            var _a, _b, _c;
+                            if (resolved)
+                                return;
+                            resolved = true;
+                            cleanup === null || cleanup === void 0 ? void 0 : cleanup();
+                            clearTimeout(timeoutId);
+                            (_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.stopBleScan();
+                            (_c = (_b = window.desktopApi) === null || _b === void 0 ? void 0 : _b.clearPreSelect) === null || _c === void 0 ? void 0 : _c.call(_b);
+                            reject(error);
+                        };
+                        const cleanup = (_c = window.desktopApi) === null || _c === void 0 ? void 0 : _c.onBleSelect(devices => {
+                            var _a;
+                            this.logDeviceListIfChanged(devices, 'acquire', `target: ${uuid}`);
+                            const targetDevice = devices.find(device => device.id === uuid);
+                            if (targetDevice) {
+                                targetDeviceName = targetDevice.name;
+                                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Transport] Target device name for matching:', targetDeviceName);
+                            }
+                        });
+                        navigator.bluetooth
+                            .requestDevice({
+                            filters: [{ services: [hdShared.ONEKEY_SERVICE_UUID] }],
+                            optionalServices: [hdShared.ONEKEY_SERVICE_UUID],
+                        })
+                            .then(selectedDevice => {
+                            var _a, _b;
+                            (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Transport] Device selected from browser:', selectedDevice.id, selectedDevice.name, 'Target UUID:', uuid, 'Target name:', targetDeviceName);
+                            if (targetDeviceName && selectedDevice.name !== targetDeviceName) {
+                                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[Transport] Selected device name does not match target:', selectedDevice.name, 'vs', targetDeviceName);
+                                cleanupAndReject(new Error(`Selected device name "${selectedDevice.name}" does not match target name "${targetDeviceName}"`));
+                                return;
+                            }
+                            cleanupAndResolve({
+                                id: selectedDevice.id,
+                                name: selectedDevice.name || 'Unknown Device',
+                                device: selectedDevice,
+                                originalUuid: uuid,
+                            });
+                        })
+                            .catch(error => {
+                            console.error('[Transport] RequestDevice error:', error);
+                        });
+                        const timeoutId = setTimeout(() => {
+                            var _a;
+                            (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Transport] Acquire timeout - v2 - waiting for device selection');
+                            cleanupAndReject(new Error('Acquire device timeout'));
+                        }, 5000);
+                    });
+                    if (!deviceInfo) {
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound);
+                    }
+                    (_o = (_m = window.desktopApi) === null || _m === void 0 ? void 0 : _m.clearPreSelect) === null || _o === void 0 ? void 0 : _o.call(_m);
+                }
+                const { device } = deviceInfo;
+                this.addDisconnectListener(device);
+                let server;
+                try {
+                    (_p = this.Log) === null || _p === void 0 ? void 0 : _p.debug('[Transport] Start connecting to device:', device.id);
+                    server = yield ((_q = device.gatt) === null || _q === void 0 ? void 0 : _q.connect());
+                    (_r = this.Log) === null || _r === void 0 ? void 0 : _r.debug('[Transport] Device gatt available:', !!device.gatt);
+                    (_s = this.Log) === null || _s === void 0 ? void 0 : _s.debug('[Transport] Device gatt connected:', (_t = device.gatt) === null || _t === void 0 ? void 0 : _t.connected);
+                    (_u = this.Log) === null || _u === void 0 ? void 0 : _u.debug('[Transport] Connected to device:', server);
+                }
+                catch (e) {
+                    (_v = this.Log) === null || _v === void 0 ? void 0 : _v.debug('[Transport] Connect to device error:', e);
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, e.message || e);
+                }
+                if (!server) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, 'Unable to connect to device');
+                }
+                let service;
+                try {
+                    (_w = this.Log) === null || _w === void 0 ? void 0 : _w.debug('[Transport] Start getting service:', hdShared.ONEKEY_SERVICE_UUID);
+                    service = yield server.getPrimaryService(hdShared.ONEKEY_SERVICE_UUID);
+                    (_x = this.Log) === null || _x === void 0 ? void 0 : _x.debug('[Transport] Got service:', service);
+                }
+                catch (e) {
+                    (_y = this.Log) === null || _y === void 0 ? void 0 : _y.debug('[Transport] Get service error:', e);
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound);
+                }
+                let writeCharacteristic;
+                let notifyCharacteristic;
+                try {
+                    (_z = this.Log) === null || _z === void 0 ? void 0 : _z.debug('[Transport] Start getting write characteristic:', hdShared.ONEKEY_WRITE_CHARACTERISTIC_UUID);
+                    writeCharacteristic = yield service.getCharacteristic(hdShared.ONEKEY_WRITE_CHARACTERISTIC_UUID);
+                    (_0 = this.Log) === null || _0 === void 0 ? void 0 : _0.debug('[Transport] Got write characteristic:', writeCharacteristic);
+                    (_1 = this.Log) === null || _1 === void 0 ? void 0 : _1.debug('[Transport] Start getting notify characteristic:', hdShared.ONEKEY_NOTIFY_CHARACTERISTIC_UUID);
+                    notifyCharacteristic = yield service.getCharacteristic(hdShared.ONEKEY_NOTIFY_CHARACTERISTIC_UUID);
+                    (_2 = this.Log) === null || _2 === void 0 ? void 0 : _2.debug('[Transport] Got notify characteristic:', notifyCharacteristic);
+                }
+                catch (e) {
+                    (_3 = this.Log) === null || _3 === void 0 ? void 0 : _3.debug('[Transport] Get characteristic error:', e);
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotFound);
+                }
+                if (!writeCharacteristic.properties.write &&
+                    !writeCharacteristic.properties.writeWithoutResponse) {
+                    throw hdShared.ERRORS.TypedError('BLECharacteristicNotWritable: write characteristic not writable');
+                }
+                if (!notifyCharacteristic.properties.notify) {
+                    throw hdShared.ERRORS.TypedError('BLECharacteristicNotNotifiable: notify characteristic not notifiable');
+                }
+                const transport = {
+                    device,
+                    server,
+                    service,
+                    writeCharacteristic,
+                    notifyCharacteristic,
+                    notifySubscription: null,
+                };
+                (_4 = this.Log) === null || _4 === void 0 ? void 0 : _4.debug('[Transport] Created transport:', transport);
+                try {
+                    (_5 = this.Log) === null || _5 === void 0 ? void 0 : _5.debug('[Transport] Start notifications:', notifyCharacteristic);
+                    yield notifyCharacteristic.startNotifications();
+                    (_6 = this.Log) === null || _6 === void 0 ? void 0 : _6.debug('[Transport] Started notifications:', notifyCharacteristic);
+                    transport.notifySubscription = this._monitorCharacteristic(notifyCharacteristic, uuid);
+                }
+                catch (e) {
+                    (_7 = this.Log) === null || _7 === void 0 ? void 0 : _7.debug('[Transport] Start notifications error:', e);
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotifyError);
+                }
+                this.transportCache[uuid] = transport;
+                if (!this.findDevice(uuid)) {
+                    this.deviceList.push(deviceInfo);
+                }
+                (_8 = this.emitter) === null || _8 === void 0 ? void 0 : _8.emit('device-connect', {
+                    name: device.name,
+                    id: device.id,
+                    connectId: device.id,
+                });
+                return { uuid, path: uuid };
+            }
+            catch (error) {
+                console.error('[Transport] Error acquiring device:', error);
+                (_9 = window.desktopApi) === null || _9 === void 0 ? void 0 : _9.stopBleScan();
+                throw error;
+            }
+        });
+    }
+    release(id) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const transport = this.transportCache[id];
+            if (!transport)
+                return;
+            const { notifyCharacteristic, notifySubscription } = transport;
+            try {
+                if (notifyCharacteristic && notifySubscription) {
+                    (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Transport] Removing notification listener for device:', id);
+                    notifyCharacteristic.removeEventListener('characteristicvaluechanged', notifySubscription);
+                    try {
+                        yield notifyCharacteristic.stopNotifications();
+                    }
+                    catch (e) {
+                        (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[Transport] Stop notifications error (ignored):', e);
+                    }
+                }
+                delete this.transportCache[id];
+                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[Transport] Device released (connection kept alive):', id);
+            }
+            catch (error) {
+                console.error('[Transport] Error releasing device:', error);
+                delete this.transportCache[id];
+            }
+        });
+    }
+    call(uuid, name, data) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._messages == null) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
+            }
+            const forceRun = name === 'Initialize' || name === 'Cancel';
+            (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('electron-ble-transport call this.runPromise', this.runPromise);
+            if (this.runPromise && !forceRun) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportCallInProgress);
+            }
+            const transport$1 = this.transportCache[uuid];
+            if (!transport$1) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotFound);
+            }
+            const { device, server } = transport$1;
+            if (!((_b = device.gatt) === null || _b === void 0 ? void 0 : _b.connected) || !(server === null || server === void 0 ? void 0 : server.connected)) {
+                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[Transport] Connection lost during call, device needs to be re-acquired');
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'Device connection lost, please re-acquire device');
+            }
+            this.runPromise = hdShared.createDeferred();
+            const messages = this._messages;
+            if (name === 'ResourceUpdate' || name === 'ResourceAck') {
+                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.debug('electron-ble-transport', 'call-', ' name: ', name, ' data: ', {
+                    file_name: data === null || data === void 0 ? void 0 : data.file_name,
+                    hash: data === null || data === void 0 ? void 0 : data.hash,
+                });
+            }
+            else if (transport.LogBlockCommand.has(name)) {
+                (_e = this.Log) === null || _e === void 0 ? void 0 : _e.debug('electron-ble-transport', 'call-', ' name: ', name);
+            }
+            else {
+                (_f = this.Log) === null || _f === void 0 ? void 0 : _f.debug('electron-ble-transport', 'call-', ' name: ', name, ' data: ', data);
+            }
+            const buffers = buildBuffers(messages, name, data);
+            function writeChunkedData(buffers, writeFunction, onError) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const packetCapacity = 512;
+                    let index = 0;
+                    let chunk = ByteBuffer__default["default"].allocate(packetCapacity);
+                    while (index < buffers.length) {
+                        const buffer = buffers[index].toBuffer();
+                        chunk.append(buffer);
+                        index += 1;
+                        if (chunk.offset === packetCapacity || index >= buffers.length) {
+                            chunk.reset();
+                            try {
+                                const arrayBuffer = chunk.toArrayBuffer();
+                                yield writeFunction(arrayBuffer);
+                                chunk = ByteBuffer__default["default"].allocate(packetCapacity);
+                            }
+                            catch (e) {
+                                onError(e);
+                                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError);
+                            }
+                        }
+                    }
+                });
+            }
+            try {
+                if (name === 'EmmcFileWrite') {
+                    yield writeChunkedData(buffers, (data) => __awaiter(this, void 0, void 0, function* () {
+                        let retries = 3;
+                        while (retries > 0) {
+                            try {
+                                yield transport$1.writeCharacteristic.writeValueWithoutResponse(data);
+                                break;
+                            }
+                            catch (e) {
+                                retries--;
+                                if (retries === 0)
+                                    throw e;
+                                yield new Promise(resolve => setTimeout(resolve, 100));
+                            }
+                        }
+                    }), e => {
+                        var _a;
+                        this.runPromise = null;
+                        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('writeCharacteristic write error: ', e);
+                    });
+                }
+                else if (name === 'FirmwareUpload') {
+                    yield writeChunkedData(buffers, (data) => __awaiter(this, void 0, void 0, function* () {
+                        yield transport$1.writeCharacteristic.writeValueWithoutResponse(data);
+                    }), e => {
+                        var _a;
+                        this.runPromise = null;
+                        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('writeCharacteristic write error: ', e);
+                    });
+                }
+                else {
+                    for (const buffer of buffers) {
+                        const arrayBuffer = buffer.toArrayBuffer();
+                        try {
+                            yield transport$1.writeCharacteristic.writeValueWithoutResponse(arrayBuffer);
+                        }
+                        catch (e) {
+                            (_g = this.Log) === null || _g === void 0 ? void 0 : _g.debug('writeCharacteristic write error: ', e);
+                            this.runPromise = null;
+                            if (e.name === 'NetworkError' || ((_h = e.message) === null || _h === void 0 ? void 0 : _h.includes('disconnected'))) {
+                                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded);
+                            }
+                            else if (e.name === 'NotSupportedError') {
+                                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError, e.message);
+                            }
+                            else {
+                                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError);
+                            }
+                        }
+                    }
+                }
+                const response = yield this.runPromise.promise;
+                if (typeof response !== 'string') {
+                    throw new Error('Returning data is not string.');
+                }
+                (_j = this.Log) === null || _j === void 0 ? void 0 : _j.debug('receive data: ', response);
+                const jsonData = receiveOne(messages, response);
+                return check.call(jsonData);
+            }
+            catch (e) {
+                (_k = this.Log) === null || _k === void 0 ? void 0 : _k.debug('call error: ', e);
+                throw e;
+            }
+            finally {
+                this.runPromise = null;
+            }
+        });
+    }
+}
+
+exports.ElectronBleTransport = ElectronBleTransport;
+exports.WebUsbTransport = WebUsbTransport;