@onekeyfe/hd-core 0.0.10 → 0.1.2

package/dist/index.js

@@ -67,6 +67,7 @@ const inject = ({ call, cancel, dispose, eventEmitter, init, uiResponse, }) => {
         solSignTransaction: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'solSignTransaction' })),
         stellarGetAddress: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'stellarGetAddress' })),
         stellarSignTransaction: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'stellarSignTransaction' })),
+        firmwareUpdate: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'firmwareUpdate' })),
     };
     return api;
 };
@@ -608,11 +609,13 @@ const ERROR_CODES = {
     Method_InvalidParameter: '',
     Call_API: '',
     Call_NotResponse: 'No response data',
+    Method_FirmwareUpdate_DownloadFailed: '',
     Transport_InvalidProtobuf: '',
     Device_FwException: '',
     Device_UnexpectedMode: '',
     Device_CallInProgress: '',
     Device_InitializeFailed: '',
+    Device_Interrupted: 'The device is performing other operations',
     Not_Use_Onekey_Device: 'Please use onekey device',
     Runtime: '',
     Init_NotInitialized: 'Init_NotInitialized',
@@ -656,7 +659,7 @@ const colors = {
     Transport: 'color: #ffb6c1; background: #000;',
 };
 const MAX_ENTRIES = 100;
-class Log$5 {
+class Log$6 {
     constructor(prefix, enabled) {
         this.prefix = prefix;
         this.enabled = enabled;
@@ -706,7 +709,7 @@ class Log$5 {
 }
 const _logs = {};
 const initLog = (prefix, enabled) => {
-    const instance = new Log$5(prefix, !!enabled);
+    const instance = new Log$6(prefix, !!enabled);
     _logs[prefix] = instance;
     return instance;
 };
@@ -720,20 +723,21 @@ const httpRequest$1 = (url, type = 'text') => __awaiter(void 0, void 0, void 0,
     const response = yield axios__default["default"].request({
         url,
         withCredentials: false,
+        responseType: type === 'binary' ? 'arraybuffer' : 'json',
     });
     if (+response.status === 200) {
         if (type === 'json') {
             return response.data;
         }
         if (type === 'binary') {
-            return response.data.arrayBuffer();
+            return response.data;
         }
         return response.data;
     }
     throw new Error(`httpRequest error: ${url} ${response.statusText}`);
 });
 
-const httpRequest = (url, _type) => httpRequest$1(url);
+const httpRequest = (url, type) => httpRequest$1(url, type);
 const getTimeStamp = () => new Date().getTime();
 
 const VER_NUMS = 3;
@@ -9751,6 +9755,21 @@ var MessagesJSON = {
 	nested: nested
 };
 
+const getReleaseStatus = (releases, currentVersion) => {
+    const newVersions = releases.filter(r => semver__default["default"].gt(r.version.join('.'), currentVersion));
+    if (newVersions.length === 0) {
+        return 'valid';
+    }
+    if (newVersions.some(r => r.required)) {
+        return 'required';
+    }
+    return 'outdated';
+};
+const getReleaseChangelog = (releases, currentVersion) => {
+    const newVersions = releases.filter(r => semver__default["default"].gt(r.version.join('.'), currentVersion));
+    return newVersions.map(r => r.changelog);
+};
+
 var _a;
 class DataManager {
     static load(settings) {
@@ -9818,17 +9837,26 @@ DataManager.getFirmwareStatus = (features) => {
         return 'unknown';
     }
     const targetDeviceConfigList = (_c = (_b = _a.deviceMap[deviceType]) === null || _b === void 0 ? void 0 : _b.firmware) !== null && _c !== void 0 ? _c : [];
-    const latestFirmware = targetDeviceConfigList[targetDeviceConfigList.length - 1];
-    if (!latestFirmware)
-        return 'valid';
-    const latestVersion = latestFirmware.version.join('.');
     const currentVersion = deviceFirmwareVersion.join('.');
-    if (semver__default["default"].gt(latestVersion, currentVersion)) {
-        if (latestFirmware.required)
-            return 'required';
-        return 'outdated';
+    return getReleaseStatus(targetDeviceConfigList, currentVersion);
+};
+DataManager.getFirmwareChangelog = (features) => {
+    var _b, _c;
+    const deviceType = getDeviceType(features);
+    const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
+    if (features.firmware_present === false ||
+        (deviceType === 'classic' && features.bootloader_mode)) {
+        return [];
     }
-    return 'valid';
+    const targetDeviceConfigList = (_c = (_b = _a.deviceMap[deviceType]) === null || _b === void 0 ? void 0 : _b.firmware) !== null && _c !== void 0 ? _c : [];
+    const currentVersion = deviceFirmwareVersion.join('.');
+    return getReleaseChangelog(targetDeviceConfigList, currentVersion);
+};
+DataManager.getFirmwareLeatestRelease = (features) => {
+    var _b, _c;
+    const deviceType = getDeviceType(features);
+    const targetDeviceConfigList = (_c = (_b = _a.deviceMap[deviceType]) === null || _b === void 0 ? void 0 : _b.firmware) !== null && _c !== void 0 ? _c : [];
+    return targetDeviceConfigList[targetDeviceConfigList.length - 1];
 };
 DataManager.getBLEFirmwareStatus = (features) => {
     var _b, _c;
@@ -9838,17 +9866,25 @@ DataManager.getBLEFirmwareStatus = (features) => {
         return 'none';
     }
     const targetDeviceConfigList = (_c = (_b = _a.deviceMap[deviceType]) === null || _b === void 0 ? void 0 : _b.ble) !== null && _c !== void 0 ? _c : [];
-    const latestBLEFirmware = targetDeviceConfigList[targetDeviceConfigList.length - 1];
-    if (!latestBLEFirmware)
-        return 'valid';
-    const latestVersion = latestBLEFirmware.version.join('.');
     const currentVersion = deviceBLEFirmwareVersion.join('.');
-    if (semver__default["default"].gt(latestVersion, currentVersion)) {
-        if (latestBLEFirmware.required)
-            return 'required';
-        return 'outdated';
+    return getReleaseStatus(targetDeviceConfigList, currentVersion);
+};
+DataManager.getBleFirmwareChangelog = (features) => {
+    var _b, _c;
+    const deviceType = getDeviceType(features);
+    const deviceBLEFirmwareVersion = getDeviceBLEFirmwareVersion(features);
+    if (!deviceBLEFirmwareVersion) {
+        return [];
     }
-    return 'valid';
+    const targetDeviceConfigList = (_c = (_b = _a.deviceMap[deviceType]) === null || _b === void 0 ? void 0 : _b.ble) !== null && _c !== void 0 ? _c : [];
+    const currentVersion = deviceBLEFirmwareVersion.join('.');
+    return getReleaseChangelog(targetDeviceConfigList, currentVersion);
+};
+DataManager.getBleFirmwareLeatestRelease = (features) => {
+    var _b, _c;
+    const deviceType = getDeviceType(features);
+    const targetDeviceConfigList = (_c = (_b = _a.deviceMap[deviceType]) === null || _b === void 0 ? void 0 : _b.ble) !== null && _c !== void 0 ? _c : [];
+    return targetDeviceConfigList[targetDeviceConfigList.length - 1];
 };
 DataManager.getTransportStatus = (localVersion) => {
     var _b, _c;
@@ -9859,7 +9895,7 @@ DataManager.getTransportStatus = (localVersion) => {
     return isLatest ? 'valid' : 'outdated';
 };
 
-const Log$4 = initLog('Transport');
+const Log$5 = initLog('Transport');
 class TransportManager {
     static load() {
         console.log('transport manager load');
@@ -9870,25 +9906,25 @@ class TransportManager {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const env = DataManager.getSettings('env');
-                Log$4.debug('Initializing transports');
+                Log$5.debug('Initializing transports');
                 if (env === 'react-native') {
                     if (!this.reactNativeInit) {
                         yield this.transport.init();
                         this.reactNativeInit = true;
                     }
                     else {
-                        Log$4.debug('React Native Do Not Initializing transports');
+                        Log$5.debug('React Native Do Not Initializing transports');
                     }
                 }
                 else {
                     yield this.transport.init();
                 }
-                Log$4.debug('Configuring transports');
+                Log$5.debug('Configuring transports');
                 yield this.transport.configure(JSON.stringify(this.defaultMessages));
-                Log$4.debug('Configuring transports done');
+                Log$5.debug('Configuring transports done');
             }
             catch (error) {
-                Log$4.debug('Initializing transports error: ', error);
+                Log$5.debug('Initializing transports error: ', error);
             }
         });
     }
@@ -9963,6 +9999,7 @@ const UI_REQUEST$1 = {
     CLOSE_UI_WINDOW: 'ui-close_window',
     BLUETOOTH_PERMISSION: 'ui-bluetooth_permission',
     LOCATION_PERMISSION: 'ui-location_permission',
+    FIRMWARE_PROGRESS: 'ui-firmware-progress',
 };
 const createUiMessage = (type, payload) => ({
     event: UI_EVENT,
@@ -9974,6 +10011,7 @@ const IFRAME = {
     INIT: 'iframe-init',
     INIT_BRIDGE: 'iframe-init-bridge',
     CALL: 'iframe-call',
+    CANCEL: 'iframe-cancel',
 };
 const createIFrameMessage = (type, payload) => ({
     event: UI_EVENT,
@@ -10030,7 +10068,7 @@ const assertType = (res, resType) => {
         throw TypedError('Runtime', `assertType: Response of unexpected type: ${res.type}. Should be ${resType}`);
     }
 };
-const Log$3 = initLog('DeviceCommands');
+const Log$4 = initLog('DeviceCommands');
 class DeviceCommands {
     constructor(device, mainId) {
         this.device = device;
@@ -10039,8 +10077,13 @@ class DeviceCommands {
         this.disposed = false;
     }
     dispose() {
+        var _a, _b;
         this.disposed = true;
+        if (this._cancelableRequest) {
+            this._cancelableRequest();
+        }
         this._cancelableRequest = undefined;
+        (_b = (_a = this.transport).cancel) === null || _b === void 0 ? void 0 : _b.call(_a);
     }
     call(type, msg = {}) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -10049,11 +10092,11 @@ class DeviceCommands {
                 const promise = this.transport.call(this.mainId, type, msg);
                 this.callPromise = promise;
                 const res = yield promise;
-                Log$3.debug('[DeviceCommands] [call] Received', res.type);
+                Log$4.debug('[DeviceCommands] [call] Received', res.type);
                 return res;
             }
             catch (error) {
-                Log$3.debug('[DeviceCommands] [call] Received error', error);
+                Log$4.debug('[DeviceCommands] [call] Received error', error);
                 throw error;
             }
         });
@@ -10246,7 +10289,7 @@ const parseRunOptions = (options) => {
         options = {};
     return options;
 };
-const Log$2 = initLog('Device');
+const Log$3 = initLog('Device');
 class Device extends events.exports {
     constructor(descriptor) {
         super();
@@ -10257,7 +10300,6 @@ class Device extends events.exports {
         this.unavailableCapabilities = {};
         this.instance = 0;
         this.internalState = [];
-        this.loaded = false;
         this.needReloadDevice = false;
         this.keepSession = false;
         this.originalDescriptor = descriptor;
@@ -10326,11 +10368,11 @@ class Device extends events.exports {
                 if (env === 'react-native') {
                     const res = yield ((_a = this.deviceConnector) === null || _a === void 0 ? void 0 : _a.acquire(this.originalDescriptor.id));
                     this.mainId = (_b = res.uuid) !== null && _b !== void 0 ? _b : '';
-                    Log$2.debug('Expected uuid:', this.mainId);
+                    Log$3.debug('Expected uuid:', this.mainId);
                 }
                 else {
                     this.mainId = yield ((_c = this.deviceConnector) === null || _c === void 0 ? void 0 : _c.acquire(this.originalDescriptor.path, this.originalDescriptor.session));
-                    Log$2.debug('Expected session id:', this.mainId);
+                    Log$3.debug('Expected session id:', this.mainId);
                 }
                 this.updateDescriptor({ [mainIdKey]: this.mainId });
                 if (this.commands) {
@@ -10371,7 +10413,7 @@ class Device extends events.exports {
                     this.updateDescriptor({ session: null });
                 }
                 catch (err) {
-                    Log$2.error('[Device] release error: ', err);
+                    Log$3.error('[Device] release error: ', err);
                 }
                 finally {
                     this.needReloadDevice = true;
@@ -10379,6 +10421,9 @@ class Device extends events.exports {
             }
         });
     }
+    getCommands() {
+        return this.commands;
+    }
     getInternalState() {
         return this.internalState[this.instance];
     }
@@ -10421,11 +10466,19 @@ class Device extends events.exports {
             this.originalDescriptor.session = upcomingSession;
         }
     }
+    updateFromCache(device) {
+        this.mainId = device.mainId;
+        this.commands = device.commands;
+        this.updateDescriptor(device.originalDescriptor);
+        if (device.features) {
+            this._updateFeatures(device.features);
+        }
+    }
     run(fn, options) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.runPromise) {
-                Log$2.error('[Device] run error:', 'Device is running');
-                throw TypedError('Device_CallInProgress');
+                this.interruption();
+                Log$3.debug('[Device] run error:', 'Device is running, but will cancel previous operate');
             }
             options = parseRunOptions(options);
             this.runPromise = create(this._runInner.bind(this, fn, options));
@@ -10452,24 +10505,26 @@ class Device extends events.exports {
             if (fn) {
                 yield fn();
             }
-            if (this.loaded && this.features) {
-                yield this.getFeatures();
-            }
             if ((!this.keepSession && typeof options.keepSession !== 'boolean') ||
                 options.keepSession === false) {
                 this.keepSession = false;
                 yield this.release();
-                Log$2.debug('release device, mainId: ', this.mainId);
+                Log$3.debug('release device, mainId: ', this.mainId);
             }
             if (this.runPromise) {
                 this.runPromise.resolve();
             }
             this.runPromise = null;
-            if (!this.loaded) {
-                this.loaded = true;
-            }
         });
     }
+    interruption() {
+        if (this.commands) {
+            this.commands.dispose();
+        }
+        if (this.runPromise) {
+            this.runPromise.reject(TypedError('Device_Interrupted'));
+        }
+    }
     getMode() {
         var _a, _b, _c;
         if ((_a = this.features) === null || _a === void 0 ? void 0 : _a.bootloader_mode)
@@ -10534,6 +10589,8 @@ class Device extends events.exports {
     }
 }
 
+const cacheDeviceMap = new Map();
+const Log$2 = initLog('DeviceList');
 class DeviceList extends events.exports {
     constructor() {
         super(...arguments);
@@ -10551,7 +10608,7 @@ class DeviceList extends events.exports {
             try {
                 for (var descriptorList_1 = __asyncValues(descriptorList), descriptorList_1_1; descriptorList_1_1 = yield descriptorList_1.next(), !descriptorList_1_1.done;) {
                     const descriptor = descriptorList_1_1.value;
-                    const device = Device.fromDescriptor(descriptor);
+                    let device = Device.fromDescriptor(descriptor);
                     device.deviceConnector = this.connector;
                     yield device.connect();
                     yield device.initialize();
@@ -10559,7 +10616,14 @@ class DeviceList extends events.exports {
                     deviceList.push(device);
                     if (device.features) {
                         const uuid = getDeviceUUID(device.features);
+                        if (cacheDeviceMap.has(uuid)) {
+                            const cache = cacheDeviceMap.get(uuid);
+                            cache === null || cache === void 0 ? void 0 : cache.updateFromCache(device);
+                            device = cache;
+                            Log$2.debug('use cache device: ', uuid);
+                        }
                         this.devices[uuid] = device;
+                        cacheDeviceMap.set(uuid, device);
                     }
                 }
             }
@@ -11555,7 +11619,13 @@ class CheckFirmwareRelease extends BaseMethod {
     run() {
         if (this.device.features) {
             const firmwareStatus = DataManager.getFirmwareStatus(this.device.features);
-            return Promise.resolve(firmwareStatus);
+            const changelog = DataManager.getFirmwareChangelog(this.device.features);
+            const release = DataManager.getFirmwareLeatestRelease(this.device.features);
+            return Promise.resolve({
+                status: firmwareStatus,
+                changelog,
+                release,
+            });
         }
         return Promise.resolve(null);
     }
@@ -11568,7 +11638,13 @@ class CheckBLEFirmwareRelease extends BaseMethod {
     run() {
         if (this.device.features) {
             const firmwareStatus = DataManager.getBLEFirmwareStatus(this.device.features);
-            return Promise.resolve(firmwareStatus);
+            const changelog = DataManager.getBleFirmwareChangelog(this.device.features);
+            const release = DataManager.getBleFirmwareLeatestRelease(this.device.features);
+            return Promise.resolve({
+                status: firmwareStatus,
+                changelog,
+                release,
+            });
         }
         return Promise.resolve(null);
     }
@@ -12830,6 +12906,120 @@ class StellarSignTransaction extends BaseMethod {
     }
 }
 
+const getBinary = ({ features, updateType, version }) => __awaiter(void 0, void 0, void 0, function* () {
+    const releaseInfo = getInfo({ features, updateType });
+    if (!releaseInfo) {
+        throw TypedError('Runtime', 'no firmware found for this device');
+    }
+    if (version &&
+        !semver__default["default"].eq(releaseInfo.version, version)) {
+        throw TypedError('Runtime', 'firmware version mismatch');
+    }
+    const url = updateType === 'ble' ? releaseInfo.webUpdate : releaseInfo.url;
+    const fw = yield httpRequest(url, 'binary');
+    return Object.assign(Object.assign({}, releaseInfo), { binary: fw });
+});
+const getInfo = ({ features, updateType }) => {
+    var _a, _b, _c;
+    const deviceType = getDeviceType(features);
+    const { deviceMap } = DataManager;
+    const releaseInfo = (_c = (_b = (_a = deviceMap === null || deviceMap === void 0 ? void 0 : deviceMap[deviceType]) === null || _a === void 0 ? void 0 : _a[updateType]) === null || _b === void 0 ? void 0 : _b[0]) !== null && _c !== void 0 ? _c : null;
+    return releaseInfo;
+};
+
+const postConfirmationMessage = (device) => {
+    var _a;
+    if ((_a = device.features) === null || _a === void 0 ? void 0 : _a.firmware_present) {
+        device.emit(DEVICE.BUTTON, device, { code: 'ButtonRequest_FirmwareUpdate' });
+    }
+};
+const postProgressMessage = (device, progress, postMessage) => {
+    postMessage(createUiMessage(UI_REQUEST$1.FIRMWARE_PROGRESS, {
+        device: device.toMessageObject(),
+        progress,
+    }));
+};
+const uploadFirmware = (updateType, typedCall, postMessage, device, { payload }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    if (((_a = device.features) === null || _a === void 0 ? void 0 : _a.major_version) === 1) {
+        postConfirmationMessage(device);
+        const eraseCommand = updateType === 'firmware' ? 'FirmwareErase' : 'FirmwareErase_ex';
+        yield typedCall(eraseCommand, 'Success', {});
+        postProgressMessage(device, 0, postMessage);
+        const { message } = yield typedCall('FirmwareUpload', 'Success', {
+            payload,
+        });
+        return message;
+    }
+    if (((_b = device.features) === null || _b === void 0 ? void 0 : _b.major_version) === 2) {
+        postConfirmationMessage(device);
+        const length = payload.byteLength;
+        let response = yield typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], { length });
+        while (response.type !== 'Success') {
+            const start = response.message.offset;
+            const end = response.message.offset + response.message.length;
+            const chunk = payload.slice(start, end);
+            if (start > 0) {
+                postProgressMessage(device, Math.round((start / length) * 100), postMessage);
+            }
+            response = yield typedCall('FirmwareUpload', ['FirmwareRequest', 'Success'], {
+                payload: chunk,
+            });
+        }
+        postProgressMessage(device, 100, postMessage);
+        return response.message;
+    }
+    throw TypedError('Runtime', 'uploadFirmware: unknown major_version');
+});
+
+class FirmwareUpdate extends BaseMethod {
+    init() {
+        this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.INITIALIZE];
+        this.requireDeviceMode = [UI_REQUEST.BOOTLOADER];
+        const { payload } = this;
+        validateParams(payload, [
+            { name: 'version', type: 'array' },
+            { name: 'binary', type: 'buffer' },
+        ]);
+        if (!payload.updateType) {
+            throw TypedError('Method_InvalidParameter', 'updateType is required');
+        }
+        this.params = { updateType: payload.updateType };
+        if ('version' in payload) {
+            this.params = Object.assign(Object.assign({}, this.params), { version: payload.version });
+        }
+        if ('binary' in payload) {
+            this.params = Object.assign(Object.assign({}, this.params), { binary: payload.binary });
+        }
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { device, params } = this;
+            let binary;
+            try {
+                if (params.binary) {
+                    binary = this.params.binary;
+                }
+                else {
+                    if (!device.features) {
+                        throw TypedError('Runtime', 'no features found for this device');
+                    }
+                    const firmware = yield getBinary({
+                        features: device.features,
+                        version: params.version,
+                        updateType: params.updateType,
+                    });
+                    binary = firmware.binary;
+                }
+            }
+            catch (err) {
+                throw TypedError('Method_FirmwareUpdate_DownloadFailed', err);
+            }
+            return uploadFirmware(params.updateType, this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, { payload: binary });
+        });
+    }
+}
+
 var ApiMethods = /*#__PURE__*/Object.freeze({
     __proto__: null,
     searchDevices: SearchDevices,
@@ -12869,7 +13059,8 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     solGetAddress: SolGetAddress,
     solSignTransaction: SolSignTransaction,
     stellarGetAddress: StellarGetAddress,
-    stellarSignTransaction: StellarSignTransaction
+    stellarSignTransaction: StellarSignTransaction,
+    firmwareUpdate: FirmwareUpdate
 });
 
 function findMethod(message) {
@@ -13033,6 +13224,7 @@ let _deviceList;
 let _connector;
 let _uiPromises = [];
 let _callPromise;
+const deviceCacheMap = new Map();
 const callAPI = (message) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b;
     if (!message.id || !message.payload || message.type !== IFRAME.CALL) {
@@ -13043,6 +13235,7 @@ const callAPI = (message) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         method = findMethod(message);
         method.connector = _connector;
+        method.postMessage = postMessage;
         method.init();
     }
     catch (error) {
@@ -13192,10 +13385,32 @@ function initDeviceForBle(method) {
     if (!method.connectId) {
         return initDevice(method);
     }
-    const device = Device.fromDescriptor({ id: method.connectId });
+    let device;
+    if (deviceCacheMap.has(method.connectId)) {
+        device = deviceCacheMap.get(method.connectId);
+    }
+    else {
+        device = Device.fromDescriptor({ id: method.connectId });
+        deviceCacheMap.set(method.connectId, device);
+    }
     device.deviceConnector = _connector;
     return device;
 }
+const cancel = (connectId) => {
+    const env = DataManager.getSettings('env');
+    if (connectId) {
+        let device;
+        if (env === 'react-native') {
+            device = initDeviceForBle({ connectId });
+        }
+        else {
+            device = initDevice({ connectId });
+        }
+        device === null || device === void 0 ? void 0 : device.interruption();
+    }
+    cleanup();
+    closePopup();
+};
 const cleanup = () => {
     _uiPromises = [];
     Log.debug('Cleanup...');
@@ -13258,6 +13473,10 @@ class Core extends events.exports {
                     const response = yield callAPI(message);
                     return response;
                 }
+                case IFRAME.CANCEL: {
+                    cancel(message.payload.connectId);
+                    break;
+                }
             }
             return Promise.resolve(message);
         });

package/dist/inject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inject.d.ts","sourceRoot":"","sources":["../src/inject.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,UAAU,CAAC;IACjB,YAAY,EAAE,YAAY,CAAC;IAC3B,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAC5B,UAAU,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;IAClC,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC3B;AAED,eAAO,MAAM,MAAM,+DAOhB,SAAS,KAAG,OA4Gd,CAAC"}
+{"version":3,"file":"inject.d.ts","sourceRoot":"","sources":["../src/inject.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,UAAU,CAAC;IACjB,YAAY,EAAE,YAAY,CAAC;IAC3B,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAC5B,UAAU,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;IAClC,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC3B;AAED,eAAO,MAAM,MAAM,+DAOhB,SAAS,KAAG,OA8Gd,CAAC"}

package/dist/types/api/checkBLEFirmwareRelease.d.ts

@@ -1,4 +1,14 @@
 import type { Response } from '../params';
-import type { IDeviceFirmwareStatus } from '../device';
-export declare function checkBLEFirmwareRelease(connectId?: string): Response<IDeviceFirmwareStatus>;
+import type { IDeviceBLEFirmwareStatus } from '../device';
+import { IBLEFirmwareReleaseInfo } from '../settings';
+declare type BleFirmwareRelease = {
+    status: IDeviceBLEFirmwareStatus;
+    changelog: {
+        'zh-CN': string;
+        'en-US': string;
+    }[];
+    release: IBLEFirmwareReleaseInfo;
+};
+export declare function checkBLEFirmwareRelease(connectId?: string): Response<BleFirmwareRelease>;
+export {};
 //# sourceMappingURL=checkBLEFirmwareRelease.d.ts.map

package/dist/types/api/checkBLEFirmwareRelease.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkBLEFirmwareRelease.d.ts","sourceRoot":"","sources":["../../../src/types/api/checkBLEFirmwareRelease.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAC7C,SAAS,CAAC,EAAE,MAAM,GACjB,QAAQ,CAAC,qBAAqB,CAAC,CAAC"}
+{"version":3,"file":"checkBLEFirmwareRelease.d.ts","sourceRoot":"","sources":["../../../src/types/api/checkBLEFirmwareRelease.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAC1D,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAEtD,aAAK,kBAAkB,GAAG;IACxB,MAAM,EAAE,wBAAwB,CAAC;IACjC,SAAS,EAAE;QACT,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;KACjB,EAAE,CAAC;IACJ,OAAO,EAAE,uBAAuB,CAAC;CAClC,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC,kBAAkB,CAAC,CAAC"}

package/dist/types/api/checkFirmwareRelease.d.ts

@@ -1,4 +1,14 @@
 import type { Response } from '../params';
 import type { IDeviceFirmwareStatus } from '../device';
-export declare function checkFirmwareRelease(connectId?: string): Response<IDeviceFirmwareStatus>;
+import { IFirmwareReleaseInfo } from '../settings';
+declare type FirmwareRelease = {
+    status: IDeviceFirmwareStatus;
+    changelog: {
+        'en-US': string;
+        'zh-CN': string;
+    }[];
+    release: IFirmwareReleaseInfo;
+};
+export declare function checkFirmwareRelease(connectId?: string): Response<FirmwareRelease>;
+export {};
 //# sourceMappingURL=checkFirmwareRelease.d.ts.map

package/dist/types/api/checkFirmwareRelease.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkFirmwareRelease.d.ts","sourceRoot":"","sources":["../../../src/types/api/checkFirmwareRelease.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,oBAAoB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC,qBAAqB,CAAC,CAAC"}
+{"version":3,"file":"checkFirmwareRelease.d.ts","sourceRoot":"","sources":["../../../src/types/api/checkFirmwareRelease.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAEnD,aAAK,eAAe,GAAG;IACrB,MAAM,EAAE,qBAAqB,CAAC;IAC9B,SAAS,EAAE;QACT,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;KACjB,EAAE,CAAC;IACJ,OAAO,EAAE,oBAAoB,CAAC;CAC/B,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,oBAAoB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC,eAAe,CAAC,CAAC"}

package/dist/types/api/firmwareUpdate.d.ts

@@ -0,0 +1,13 @@
+import type { PROTO } from '../../constants';
+import type { Params, Response } from '../params';
+export interface FirmwareUpdateBinary {
+    binary: ArrayBuffer;
+}
+export interface FirmwareUpdate {
+    version: number[];
+    btcOnly?: boolean;
+    updateType: 'firmware' | 'ble';
+}
+export declare function firmwareUpdate(connectId: string | undefined, params: Params<FirmwareUpdate>): Response<PROTO.Success>;
+export declare function firmwareUpdate(connectId: string | undefined, params: Params<FirmwareUpdateBinary>): Response<PROTO.Success>;
+//# sourceMappingURL=firmwareUpdate.d.ts.map

package/dist/types/api/firmwareUpdate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"firmwareUpdate.d.ts","sourceRoot":"","sources":["../../../src/types/api/firmwareUpdate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAElD,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,EAAE,UAAU,GAAG,KAAK,CAAC;CAChC;AAED,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC,GAC7B,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;AAC3B,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,MAAM,EAAE,MAAM,CAAC,oBAAoB,CAAC,GACnC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC"}