@onekeyfe/hd-transport 1.2.0-alpha.1 → 1.2.0-alpha.10

package/dist/index.js

@@ -249,7 +249,11 @@ const createMessageFromName = (messages, name) => {
 };
 const createMessageFromType = (messages, typeId) => {
     const MessageType = messages.lookupEnum('MessageType');
-    const messageName = MessageType.valuesById[typeId].replace('MessageType_', '');
+    const rawMessageName = MessageType.valuesById[typeId];
+    if (!rawMessageName) {
+        throw new Error(`MessageType id "${typeId}" is not defined in protobuf schema`);
+    }
+    const messageName = rawMessageName.replace('MessageType_', '');
     const Message = messages.lookupType(messageName);
     return {
         Message,
@@ -264,8 +268,10 @@ const PROTOCOL_V1_USB_PACKET_SIZE = PROTOCOL_V1_CHUNK_PAYLOAD_SIZE + 1;
 const PROTOCOL_V1_MESSAGE_HEADER_SIZE = 2 + 4;
 const PROTOCOL_V1_ENVELOPE_HEADER_SIZE = 1 + 1 + PROTOCOL_V1_MESSAGE_HEADER_SIZE;
 const PROTOCOL_V2_FRAME_MAX_BYTES = 4608;
-const PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE = 4096;
+const PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE = 4000;
 const PROTOCOL_V2_BLE_FILE_CHUNK_SIZE = 1800;
+const PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE = 900;
+const PROTOCOL_V2_BLE_FRAME_MAX_BYTES = 2048;
 const PROTOCOL_V2_FILE_CHUNK_SIZE = PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
 const PROTOCOL_V2_CHANNEL_USB = 0;
 const PROTOCOL_V2_CHANNEL_BLE_UART = 1;
@@ -377,6 +383,7 @@ const PROTO_HEAD_CRC_SIZE = 8;
 const CRC8_INIT = 0x30;
 const PACKET_SIZE = 4096;
 const PROTO_DATA_TYPE_PACKET = 0;
+const PROTO_DATA_TYPE_ACK = 1;
 
 const CRC8_TABLE = new Uint8Array([
     0x00, 0x5e, 0xbc, 0xe2, 0x61, 0x3f, 0xdd, 0x83, 0xc2, 0x9c, 0x7e, 0x20, 0xa3, 0xfd, 0x1f, 0x41,
@@ -458,7 +465,7 @@ function encodeProtobufFrame(messageTypeId, pbPayload, packetSrc, router, debugO
     return encodeFrame(payload, packetSrc, router, Object.assign(Object.assign({}, debugOptions), { messageTypeId, pbPayloadLength: pbPayload.length }), seq);
 }
 
-function decodeFrame(data, debugOptions) {
+function validateFrame(data) {
     if (data.length < PROTO_HEAD_CRC_SIZE) {
         throw new Error(`Protocol V2 frame too short: ${data.length} bytes`);
     }
@@ -481,6 +488,22 @@ function decodeFrame(data, debugOptions) {
             .toString(16)
             .padStart(2, '0')}, got 0x${data[frameLen - 1].toString(16).padStart(2, '0')}`);
     }
+    return frameLen;
+}
+function isAckFrame(data) {
+    if (data.length < 6 || (data[5] & 0x03) !== PROTO_DATA_TYPE_ACK) {
+        return false;
+    }
+    const frameLen = validateFrame(data);
+    if (frameLen !== PROTO_HEAD_CRC_SIZE) {
+        throw new Error(`Invalid Protocol V2 ACK frame length: ${frameLen}`);
+    }
+    return true;
+}
+function decodeFrame(data, debugOptions) {
+    const frameLen = validateFrame(data);
+    const expectedHeaderCrc = data[3];
+    const expectedFrameCrc = data[frameLen - 1];
     const seq = data[6];
     const payloadData = data.slice(7, frameLen - 1);
     if (payloadData.length < 2) {
@@ -583,12 +606,14 @@ var protocolV2Codec = /*#__PURE__*/Object.freeze({
     CRC8_INIT: CRC8_INIT,
     PACKET_SIZE: PACKET_SIZE,
     PROTO_DATA_TYPE_PACKET: PROTO_DATA_TYPE_PACKET,
+    PROTO_DATA_TYPE_ACK: PROTO_DATA_TYPE_ACK,
     CRC8_TABLE: CRC8_TABLE,
     crc8: crc8,
     logProtocolV2Debug: logProtocolV2Debug,
     nextProtoSeq: nextProtoSeq,
     encodeFrame: encodeFrame,
     encodeProtobufFrame: encodeProtobufFrame,
+    isAckFrame: isAckFrame,
     decodeFrame: decodeFrame,
     concatUint8Arrays: concatUint8Arrays,
     ProtocolV2FrameAssembler: ProtocolV2FrameAssembler
@@ -605,6 +630,7 @@ const resolveProtocolV2EncodeSchema = (name, schemas) => {
     }
 };
 const PROTOCOL_V2_LEGACY_DECODE_ALLOWLIST = new Set([
+    'Failure',
     'ButtonRequest',
     'EntropyRequest',
     'PinMatrixRequest',
@@ -638,6 +664,7 @@ const ProtocolV1 = {
     decodeMessage: decodeMessage,
 };
 const ProtocolV2 = {
+    isAckFrame,
     encodeFrame(schemas, name, data, options = {}) {
         var _a, _b, _c, _d, _e, _f, _g;
         const encodeMessages = resolveProtocolV2EncodeSchema(name, schemas);
@@ -700,6 +727,16 @@ var index$1 = /*#__PURE__*/Object.freeze({
     decodeMessage: decodeMessage
 });
 
+class ProtocolV2SequenceCursor {
+    constructor() {
+        this.current = 0;
+    }
+    next() {
+        this.current = nextProtoSeq(this.current);
+        return this.current;
+    }
+}
+
 const ERROR = 'Wrong result type.';
 function info(res) {
     if (typeof res !== 'object' || res == null) {
@@ -951,12 +988,13 @@ function withProtocolTimeout(promise, timeoutMs, createTimeoutError, onTimeout)
         }
     });
 }
-const PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS = 30000;
+const PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS = 0;
 class ProtocolV2Session {
     constructor(options) {
+        var _a;
         this.pendingCall = Promise.resolve();
-        this.protoSeq = 0;
         this.options = options;
+        this.sequenceCursor = (_a = options.sequenceCursor) !== null && _a !== void 0 ? _a : new ProtocolV2SequenceCursor();
     }
     call(name, data, callOptions = {}) {
         const run = () => this.executeCall(name, data, callOptions);
@@ -967,55 +1005,73 @@ class ProtocolV2Session {
     executeCall(name, data, callOptions) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            const { schemas, router, packetSrc = PROTOCOL_V2_PACKET_SRC_COMMAND, writeFrame, readFrame, logger, logPrefix = 'ProtocolV2', createTimeoutError, } = this.options;
+            const { schemas, router, packetSrc = PROTOCOL_V2_PACKET_SRC_COMMAND, maxFrameBytes, prepareCall, writeFrame, readFrame, logger, logPrefix = 'ProtocolV2', createTimeoutError, generation = 0, } = this.options;
             const shouldReduceDebug = shouldReduceProtocolV2Debug(name);
-            this.protoSeq = nextProtoSeq(this.protoSeq);
+            const callContext = {
+                messageName: name,
+                timeoutMs: callOptions.timeoutMs,
+                highVolume: shouldReduceDebug,
+                generation,
+            };
+            yield (prepareCall === null || prepareCall === void 0 ? void 0 : prepareCall(callContext));
+            const protoSeq = this.sequenceCursor.next();
             const frame = ProtocolV2.encodeFrame(schemas, name, data, {
                 packetSrc,
                 router,
-                seq: this.protoSeq,
+                seq: protoSeq,
                 logger: shouldReduceDebug ? undefined : logger,
                 logPrefix,
                 context: `tx:${name}`,
             });
             const expectedSeq = frame[6];
+            if (maxFrameBytes !== undefined && frame.length > maxFrameBytes) {
+                throw new Error(`Protocol V2 frame too large for transport: ${frame.length} > ${maxFrameBytes}`);
+            }
             if (!shouldReduceDebug) {
                 (_a = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _a === void 0 ? void 0 : _a.call(logger, `[${logPrefix}] TX payload name=${name}`, sanitizeProtocolV2DebugPayload(data));
                 (_b = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _b === void 0 ? void 0 : _b.call(logger, `[${logPrefix}] TX frame name=${name} len=${frame.length} router=${frame[4]} attr=${frame[5]} seq=${expectedSeq} headerHex=${frameHeaderDebugHex(frame)}`);
             }
-            yield withProtocolTimeout(writeFrame(frame), PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS, () => new Error(`Protocol V2 write timeout after ${PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS}ms for ${name}`));
+            yield withProtocolTimeout(writeFrame(frame, callContext), PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS, () => new Error(`Protocol V2 write timeout after ${PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS}ms for ${name}`));
             const cancellation = { cancelled: false };
             const readResponse = () => __awaiter(this, void 0, void 0, function* () {
-                var _c, _d, _e, _f, _g, _h, _j, _k;
+                var _c, _d, _e, _f, _g, _h, _j, _k, _l;
                 while (!cancellation.cancelled) {
-                    const rxFrame = yield readFrame();
+                    const rxFrame = yield readFrame(callContext);
                     if (cancellation.cancelled) {
                         break;
                     }
                     if (!shouldReduceDebug) {
                         (_c = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _c === void 0 ? void 0 : _c.call(logger, `[${logPrefix}] RX frame len=${rxFrame.length} router=${rxFrame[4]} attr=${rxFrame[5]} seq=${rxFrame[6]} headerHex=${frameHeaderDebugHex(rxFrame)}`);
                     }
-                    const decoded = ProtocolV2.decodeFrame(schemas, rxFrame, {
-                        logger: shouldReduceDebug ? undefined : logger,
-                        logPrefix,
-                        context: `rx:${name}`,
-                    });
-                    if (!shouldReduceDebug && decoded.seq !== expectedSeq) {
-                        (_d = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _d === void 0 ? void 0 : _d.call(logger, `[${logPrefix}] seq differs for ${name}: tx=${expectedSeq}, rx=${decoded.seq}`);
-                    }
-                    if (!shouldReduceDebug) {
-                        (_e = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _e === void 0 ? void 0 : _e.call(logger, `[${logPrefix}] TX name=${name} seq=${expectedSeq} | RX seq=${decoded.seq} messageTypeId=${decoded.messageTypeId} pbPayload=${decoded.pbPayload.length}B`);
-                        (_f = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _f === void 0 ? void 0 : _f.call(logger, `[${logPrefix}] RX payload type=${decoded.type} messageTypeId=${decoded.messageTypeId}`, sanitizeProtocolV2DebugPayload(decoded.message));
-                    }
-                    const response = call(decoded);
-                    if ((_g = callOptions.intermediateTypes) === null || _g === void 0 ? void 0 : _g.includes(response.type)) {
-                        (_h = callOptions.onIntermediateResponse) === null || _h === void 0 ? void 0 : _h.call(callOptions, response);
-                    }
-                    else if (isExpectedTerminalResponse(response, callOptions.expectedTypes)) {
-                        return response;
+                    const isAck = ProtocolV2.isAckFrame(rxFrame);
+                    if (isAck) {
+                        if (!shouldReduceDebug) {
+                            (_d = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _d === void 0 ? void 0 : _d.call(logger, `[${logPrefix}] skip Proto Link ACK seq=${rxFrame[6]}`);
+                        }
                     }
-                    else if (!shouldReduceDebug) {
-                        (_j = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _j === void 0 ? void 0 : _j.call(logger, `[${logPrefix}] skip unexpected response for ${name}: expected=${(_k = callOptions.expectedTypes) === null || _k === void 0 ? void 0 : _k.join('|')} got=${response.type}`);
+                    if (!isAck) {
+                        const decoded = ProtocolV2.decodeFrame(schemas, rxFrame, {
+                            logger: shouldReduceDebug ? undefined : logger,
+                            logPrefix,
+                            context: `rx:${name}`,
+                        });
+                        if (!shouldReduceDebug && decoded.seq !== expectedSeq) {
+                            (_e = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _e === void 0 ? void 0 : _e.call(logger, `[${logPrefix}] seq differs for ${name}: tx=${expectedSeq}, rx=${decoded.seq}`);
+                        }
+                        if (!shouldReduceDebug) {
+                            (_f = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _f === void 0 ? void 0 : _f.call(logger, `[${logPrefix}] TX name=${name} seq=${expectedSeq} | RX seq=${decoded.seq} messageTypeId=${decoded.messageTypeId} pbPayload=${decoded.pbPayload.length}B`);
+                            (_g = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _g === void 0 ? void 0 : _g.call(logger, `[${logPrefix}] RX payload type=${decoded.type} messageTypeId=${decoded.messageTypeId}`, sanitizeProtocolV2DebugPayload(decoded.message));
+                        }
+                        const response = call(decoded);
+                        if ((_h = callOptions.intermediateTypes) === null || _h === void 0 ? void 0 : _h.includes(response.type)) {
+                            (_j = callOptions.onIntermediateResponse) === null || _j === void 0 ? void 0 : _j.call(callOptions, response);
+                        }
+                        else if (isExpectedTerminalResponse(response, callOptions.expectedTypes)) {
+                            return response;
+                        }
+                        else if (!shouldReduceDebug) {
+                            (_k = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _k === void 0 ? void 0 : _k.call(logger, `[${logPrefix}] skip unexpected response for ${name}: expected=${(_l = callOptions.expectedTypes) === null || _l === void 0 ? void 0 : _l.join('|')} got=${response.type}`);
+                        }
                     }
                 }
                 throw new Error(`Protocol V2 read loop cancelled after timeout for ${name}`);
@@ -1052,6 +1108,247 @@ function probeProtocolV2({ call, timeoutMs, logger, logPrefix = 'ProtocolV2', on
     });
 }
 
+class ProtocolV2LinkManager {
+    constructor(options) {
+        this.links = new Map();
+        this.sequences = new Map();
+        this.callQueues = new Map();
+        this.options = options;
+    }
+    call(key, createAdapter, name, data, options) {
+        var _a;
+        const run = () => this.executeCall(key, createAdapter, name, data, options);
+        const previous = (_a = this.callQueues.get(key)) !== null && _a !== void 0 ? _a : Promise.resolve();
+        const result = previous.then(run, run);
+        const queue = result.catch(() => undefined);
+        this.callQueues.set(key, queue);
+        result
+            .then(() => this.clearSettledCallQueue(key, queue), () => this.clearSettledCallQueue(key, queue))
+            .catch(() => undefined);
+        return result;
+    }
+    invalidateLink(key, reason) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const link = this.links.get(key);
+            if (!link)
+                return;
+            this.links.delete(key);
+            link.state.invalidatedReason = reason;
+            yield link.adapter.reset(reason);
+            yield ((_b = (_a = this.options).onLinkInvalidated) === null || _b === void 0 ? void 0 : _b.call(_a, key, reason));
+        });
+    }
+    invalidateAllLinks(reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(Array.from(this.links.keys(), key => this.invalidateLink(key, reason)));
+        });
+    }
+    dispose(reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.invalidateAllLinks(reason);
+            this.sequences.clear();
+            this.callQueues.clear();
+        });
+    }
+    getOrCreateLink(key, createAdapter) {
+        const existing = this.links.get(key);
+        if (existing)
+            return existing;
+        const adapter = createAdapter();
+        const state = {};
+        const assertLinkActive = () => {
+            if (state.invalidatedReason) {
+                throw new Error(state.invalidatedReason);
+            }
+        };
+        let sequenceCursor = this.sequences.get(key);
+        if (!sequenceCursor) {
+            sequenceCursor = new ProtocolV2SequenceCursor();
+            this.sequences.set(key, sequenceCursor);
+        }
+        const session = new ProtocolV2Session({
+            schemas: this.options.getSchemas(),
+            router: adapter.router,
+            maxFrameBytes: adapter.maxFrameBytes,
+            generation: adapter.generation,
+            sequenceCursor,
+            prepareCall: (context) => __awaiter(this, void 0, void 0, function* () {
+                assertLinkActive();
+                yield adapter.prepareCall(context);
+                assertLinkActive();
+            }),
+            writeFrame: (frame, context) => __awaiter(this, void 0, void 0, function* () {
+                assertLinkActive();
+                yield adapter.writeFrame(frame, context);
+                assertLinkActive();
+            }),
+            readFrame: (context) => __awaiter(this, void 0, void 0, function* () {
+                assertLinkActive();
+                const frame = yield adapter.readFrame(context);
+                assertLinkActive();
+                return frame;
+            }),
+            logger: adapter.logger,
+            logPrefix: adapter.logPrefix,
+            createTimeoutError: adapter.createTimeoutError,
+        });
+        const link = { adapter, session, state };
+        this.links.set(key, link);
+        return link;
+    }
+    executeCall(key, createAdapter, name, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.getOrCreateLink(key, createAdapter).session.call(name, data, options);
+            }
+            catch (error) {
+                if (this.options.classifyError(error) === 'link-fatal') {
+                    const errorMessage = getErrorMessage(error) || 'unknown error';
+                    yield this.invalidateLink(key, `Protocol V2 link-fatal error: ${errorMessage}`);
+                }
+                throw error;
+            }
+        });
+    }
+    clearSettledCallQueue(key, queue) {
+        if (this.callQueues.get(key) === queue) {
+            this.callQueues.delete(key);
+        }
+    }
+}
+
+class ProtocolV2UsbTransportBase {
+    constructor(options) {
+        this.protocolV2UsbAssemblers = new Map();
+        this.protocolV2UsbGenerations = new Map();
+        this.protocolV2UsbCancellations = new Map();
+        this.protocolV2UsbOptions = options;
+        this.protocolV2UsbLinks = new ProtocolV2LinkManager({
+            getSchemas: () => this.getProtocolV2UsbSchemas(),
+            classifyError: () => 'link-fatal',
+            onLinkInvalidated: (key, reason) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                (_a = this.protocolV2UsbAssemblers.get(key)) === null || _a === void 0 ? void 0 : _a.reset();
+                yield this.resetProtocolV2UsbNativeLink(key, reason);
+                yield this.onProtocolV2UsbLinkInvalidated(key, reason);
+            }),
+        });
+    }
+    onProtocolV2UsbLinkInvalidated(_key, _reason) {
+    }
+    rotateProtocolV2UsbGeneration(key, reason) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.protocolV2UsbLinks.invalidateLink(key, reason);
+            const generation = ((_a = this.protocolV2UsbGenerations.get(key)) !== null && _a !== void 0 ? _a : 0) + 1;
+            this.protocolV2UsbGenerations.set(key, generation);
+            this.protocolV2UsbCancellations.set(key, this.createProtocolV2UsbCancellation(generation));
+            this.protocolV2UsbAssemblers.set(key, new ProtocolV2FrameAssembler(this.protocolV2UsbOptions.maxFrameBytes));
+            return generation;
+        });
+    }
+    callProtocolV2Usb(key, name, data, options) {
+        return this.protocolV2UsbLinks.call(key, () => this.createProtocolV2UsbAdapter(key), name, data, options);
+    }
+    invalidateProtocolV2UsbLink(key, reason) {
+        return this.protocolV2UsbLinks.invalidateLink(key, reason);
+    }
+    invalidateAllProtocolV2UsbLinks(reason) {
+        return this.protocolV2UsbLinks.invalidateAllLinks(reason);
+    }
+    disposeProtocolV2UsbLinks(reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.protocolV2UsbLinks.dispose(reason);
+            this.protocolV2UsbAssemblers.clear();
+            this.protocolV2UsbGenerations.clear();
+            this.protocolV2UsbCancellations.clear();
+        });
+    }
+    createProtocolV2UsbAdapter(key) {
+        const generation = this.protocolV2UsbGenerations.get(key);
+        if (generation === undefined) {
+            throw new Error('Protocol V2 USB generation has not been initialized');
+        }
+        const cancellation = this.protocolV2UsbCancellations.get(key);
+        if (!cancellation || cancellation.generation !== generation) {
+            throw new Error('Protocol V2 USB cancellation state has not been initialized');
+        }
+        const assertCurrentGeneration = () => {
+            if (cancellation.reason) {
+                throw new Error(cancellation.reason);
+            }
+            if (this.protocolV2UsbGenerations.get(key) !== generation) {
+                throw new Error('Protocol V2 USB connection generation changed');
+            }
+        };
+        return {
+            router: this.protocolV2UsbOptions.router,
+            maxFrameBytes: this.protocolV2UsbOptions.maxFrameBytes,
+            generation,
+            prepareCall: () => {
+                assertCurrentGeneration();
+                this.getProtocolV2UsbAssembler(key).reset();
+            },
+            writeFrame: (frame, context) => __awaiter(this, void 0, void 0, function* () {
+                assertCurrentGeneration();
+                yield this.writeProtocolV2UsbPacket(key, frame, context);
+                assertCurrentGeneration();
+            }),
+            readFrame: (context) => __awaiter(this, void 0, void 0, function* () {
+                assertCurrentGeneration();
+                const assembler = this.getProtocolV2UsbAssembler(key);
+                let frame = assembler.push(new Uint8Array(0));
+                while (!frame) {
+                    const packetRead = this.readProtocolV2UsbPacket(key, context).then(packet => ({
+                        packet,
+                    }));
+                    const cancelled = cancellation.promise.then(reason => ({ reason }));
+                    const result = yield Promise.race([packetRead, cancelled]);
+                    if ('reason' in result) {
+                        throw new Error(result.reason);
+                    }
+                    assertCurrentGeneration();
+                    frame = assembler.push(result.packet);
+                }
+                assertCurrentGeneration();
+                return frame;
+            }),
+            reset: (reason) => {
+                var _a;
+                cancellation.cancel(reason);
+                (_a = this.protocolV2UsbAssemblers.get(key)) === null || _a === void 0 ? void 0 : _a.reset();
+            },
+            logger: this.getProtocolV2UsbLogger(),
+            logPrefix: this.protocolV2UsbOptions.logPrefix,
+            createTimeoutError: (messageName, timeoutMs) => this.createProtocolV2UsbTimeoutError(messageName, timeoutMs),
+        };
+    }
+    getProtocolV2UsbAssembler(key) {
+        const assembler = this.protocolV2UsbAssemblers.get(key);
+        if (!assembler) {
+            throw new Error('Protocol V2 USB assembler has not been initialized');
+        }
+        return assembler;
+    }
+    createProtocolV2UsbCancellation(generation) {
+        let resolveCancellation = () => undefined;
+        const cancellation = {
+            generation,
+            promise: new Promise(resolve => {
+                resolveCancellation = resolve;
+            }),
+            cancel: reason => {
+                if (cancellation.reason)
+                    return;
+                cancellation.reason = reason;
+                resolveCancellation(reason);
+            },
+        };
+        return cancellation;
+    }
+}
+
 exports.AptosTransactionType = void 0;
 (function (AptosTransactionType) {
     AptosTransactionType[AptosTransactionType["STANDARD"] = 0] = "STANDARD";
@@ -1227,6 +1524,9 @@ exports.FailureType = void 0;
     FailureType[FailureType["Failure_WipeCodeMismatch"] = 13] = "Failure_WipeCodeMismatch";
     FailureType[FailureType["Failure_InvalidSession"] = 14] = "Failure_InvalidSession";
     FailureType[FailureType["Failure_FirmwareError"] = 99] = "Failure_FirmwareError";
+    FailureType[FailureType["Failure_InvalidMessage"] = 1] = "Failure_InvalidMessage";
+    FailureType[FailureType["Failure_UndefinedError"] = 2] = "Failure_UndefinedError";
+    FailureType[FailureType["Failure_UsageError"] = 3] = "Failure_UsageError";
 })(exports.FailureType || (exports.FailureType = {}));
 exports.Enum_ButtonRequestType = void 0;
 (function (Enum_ButtonRequestType) {
@@ -1508,12 +1808,50 @@ exports.ViewTipType = void 0;
     ViewTipType[ViewTipType["Warning"] = 3] = "Warning";
     ViewTipType[ViewTipType["Danger"] = 4] = "Danger";
 })(exports.ViewTipType || (exports.ViewTipType = {}));
-exports.DevRebootType = void 0;
-(function (DevRebootType) {
-    DevRebootType[DevRebootType["Normal"] = 0] = "Normal";
-    DevRebootType[DevRebootType["Boardloader"] = 1] = "Boardloader";
-    DevRebootType[DevRebootType["Bootloader"] = 2] = "Bootloader";
-})(exports.DevRebootType || (exports.DevRebootType = {}));
+exports.ViewSignLayout = void 0;
+(function (ViewSignLayout) {
+    ViewSignLayout[ViewSignLayout["LayoutDefault"] = 0] = "LayoutDefault";
+    ViewSignLayout[ViewSignLayout["LayoutSafeTxCreate"] = 1] = "LayoutSafeTxCreate";
+})(exports.ViewSignLayout || (exports.ViewSignLayout = {}));
+exports.DeviceRebootType = void 0;
+(function (DeviceRebootType) {
+    DeviceRebootType[DeviceRebootType["Normal"] = 0] = "Normal";
+    DeviceRebootType[DeviceRebootType["Romloader"] = 1] = "Romloader";
+    DeviceRebootType[DeviceRebootType["Bootloader"] = 2] = "Bootloader";
+})(exports.DeviceRebootType || (exports.DeviceRebootType = {}));
+exports.DeviceFirmwareTargetType = void 0;
+(function (DeviceFirmwareTargetType) {
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_INVALID"] = 0] = "FW_MGMT_TARGET_INVALID";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_CRATE"] = 1] = "FW_MGMT_TARGET_CRATE";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_ROMLOADER"] = 2] = "FW_MGMT_TARGET_ROMLOADER";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_BOOTLOADER"] = 3] = "FW_MGMT_TARGET_BOOTLOADER";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_APPLICATION_P1"] = 4] = "FW_MGMT_TARGET_APPLICATION_P1";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_APPLICATION_P2"] = 5] = "FW_MGMT_TARGET_APPLICATION_P2";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_COPROCESSOR"] = 6] = "FW_MGMT_TARGET_COPROCESSOR";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_SE01"] = 7] = "FW_MGMT_TARGET_SE01";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_SE02"] = 8] = "FW_MGMT_TARGET_SE02";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_SE03"] = 9] = "FW_MGMT_TARGET_SE03";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_SE04"] = 10] = "FW_MGMT_TARGET_SE04";
+})(exports.DeviceFirmwareTargetType || (exports.DeviceFirmwareTargetType = {}));
+exports.DeviceFirmwareUpdateTaskStatus = void 0;
+(function (DeviceFirmwareUpdateTaskStatus) {
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_PENDING"] = 0] = "FW_MGMT_UPDATER_TASK_STATUS_PENDING";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_IN_PROGRESS"] = 1] = "FW_MGMT_UPDATER_TASK_STATUS_IN_PROGRESS";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_FINISHED"] = 2] = "FW_MGMT_UPDATER_TASK_STATUS_FINISHED";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_FAILED_FILE_NOT_FOUND"] = 3] = "FW_MGMT_UPDATER_TASK_STATUS_FAILED_FILE_NOT_FOUND";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_FAILED_FILE_READ"] = 4] = "FW_MGMT_UPDATER_TASK_STATUS_FAILED_FILE_READ";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_FAILED_FILE_WRITE"] = 5] = "FW_MGMT_UPDATER_TASK_STATUS_FAILED_FILE_WRITE";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_FAILED_VERIFY"] = 6] = "FW_MGMT_UPDATER_TASK_STATUS_FAILED_VERIFY";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_FAILED_INSTALL"] = 7] = "FW_MGMT_UPDATER_TASK_STATUS_FAILED_INSTALL";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_FAILED_ABORT"] = 8] = "FW_MGMT_UPDATER_TASK_STATUS_FAILED_ABORT";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_FAILED_BUSY"] = 9] = "FW_MGMT_UPDATER_TASK_STATUS_FAILED_BUSY";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_FAILED_ENTRY_OUT_OF_BOUNDS"] = 10] = "FW_MGMT_UPDATER_TASK_STATUS_FAILED_ENTRY_OUT_OF_BOUNDS";
+})(exports.DeviceFirmwareUpdateTaskStatus || (exports.DeviceFirmwareUpdateTaskStatus = {}));
+exports.DeviceFactoryAck = void 0;
+(function (DeviceFactoryAck) {
+    DeviceFactoryAck[DeviceFactoryAck["FACTORY_ACK_SUCCESS"] = 0] = "FACTORY_ACK_SUCCESS";
+    DeviceFactoryAck[DeviceFactoryAck["FACTORY_ACK_FAIL"] = 1] = "FACTORY_ACK_FAIL";
+})(exports.DeviceFactoryAck || (exports.DeviceFactoryAck = {}));
 exports.DeviceType = void 0;
 (function (DeviceType) {
     DeviceType[DeviceType["CLASSIC1"] = 0] = "CLASSIC1";
@@ -1522,37 +1860,36 @@ exports.DeviceType = void 0;
     DeviceType[DeviceType["TOUCH"] = 3] = "TOUCH";
     DeviceType[DeviceType["PRO"] = 5] = "PRO";
     DeviceType[DeviceType["CLASSIC1S_PURE"] = 6] = "CLASSIC1S_PURE";
+    DeviceType[DeviceType["PRO2"] = 7] = "PRO2";
+    DeviceType[DeviceType["NEO"] = 8] = "NEO";
 })(exports.DeviceType || (exports.DeviceType = {}));
-exports.DevSeType = void 0;
-(function (DevSeType) {
-    DevSeType[DevSeType["THD89"] = 0] = "THD89";
-    DevSeType[DevSeType["SE608A"] = 1] = "SE608A";
-})(exports.DevSeType || (exports.DevSeType = {}));
-exports.DevSEState = void 0;
-(function (DevSEState) {
-    DevSEState[DevSEState["BOOT"] = 0] = "BOOT";
-    DevSEState[DevSEState["APP_FACTORY"] = 51] = "APP_FACTORY";
-    DevSEState[DevSEState["APP"] = 85] = "APP";
-})(exports.DevSEState || (exports.DevSEState = {}));
-exports.DevFirmwareTargetType = void 0;
-(function (DevFirmwareTargetType) {
-    DevFirmwareTargetType[DevFirmwareTargetType["TARGET_MAIN_APP"] = 0] = "TARGET_MAIN_APP";
-    DevFirmwareTargetType[DevFirmwareTargetType["TARGET_MAIN_BOOT"] = 1] = "TARGET_MAIN_BOOT";
-    DevFirmwareTargetType[DevFirmwareTargetType["TARGET_BT"] = 2] = "TARGET_BT";
-    DevFirmwareTargetType[DevFirmwareTargetType["TARGET_SE1"] = 3] = "TARGET_SE1";
-    DevFirmwareTargetType[DevFirmwareTargetType["TARGET_SE2"] = 4] = "TARGET_SE2";
-    DevFirmwareTargetType[DevFirmwareTargetType["TARGET_SE3"] = 5] = "TARGET_SE3";
-    DevFirmwareTargetType[DevFirmwareTargetType["TARGET_SE4"] = 6] = "TARGET_SE4";
-    DevFirmwareTargetType[DevFirmwareTargetType["TARGET_RESOURCE"] = 10] = "TARGET_RESOURCE";
-})(exports.DevFirmwareTargetType || (exports.DevFirmwareTargetType = {}));
-exports.OnboardingStep = void 0;
-(function (OnboardingStep) {
-    OnboardingStep[OnboardingStep["ONBOARDING_STEP_UNKNOWN"] = 0] = "ONBOARDING_STEP_UNKNOWN";
-    OnboardingStep[OnboardingStep["ONBOARDING_STEP_DEVICE_VERIFICATION"] = 1] = "ONBOARDING_STEP_DEVICE_VERIFICATION";
-    OnboardingStep[OnboardingStep["ONBOARDING_STEP_PERSONALIZATION"] = 2] = "ONBOARDING_STEP_PERSONALIZATION";
-    OnboardingStep[OnboardingStep["ONBOARDING_STEP_SETUP"] = 3] = "ONBOARDING_STEP_SETUP";
-    OnboardingStep[OnboardingStep["ONBOARDING_STEP_FIRMWARE"] = 4] = "ONBOARDING_STEP_FIRMWARE";
-})(exports.OnboardingStep || (exports.OnboardingStep = {}));
+exports.DeviceSeType = void 0;
+(function (DeviceSeType) {
+    DeviceSeType[DeviceSeType["THD89"] = 0] = "THD89";
+    DeviceSeType[DeviceSeType["SE608A"] = 1] = "SE608A";
+})(exports.DeviceSeType || (exports.DeviceSeType = {}));
+exports.DeviceSEState = void 0;
+(function (DeviceSEState) {
+    DeviceSEState[DeviceSEState["BOOT"] = 0] = "BOOT";
+    DeviceSEState[DeviceSEState["APP_FACTORY"] = 51] = "APP_FACTORY";
+    DeviceSEState[DeviceSEState["APP"] = 85] = "APP";
+})(exports.DeviceSEState || (exports.DeviceSEState = {}));
+exports.DevOnboardingStage = void 0;
+(function (DevOnboardingStage) {
+    DevOnboardingStage[DevOnboardingStage["DEV_ONBOARDING_STAGE_UNKNOWN"] = 0] = "DEV_ONBOARDING_STAGE_UNKNOWN";
+    DevOnboardingStage[DevOnboardingStage["DEV_ONBOARDING_STAGE_SAFETY_CHECK"] = 1] = "DEV_ONBOARDING_STAGE_SAFETY_CHECK";
+    DevOnboardingStage[DevOnboardingStage["DEV_ONBOARDING_STAGE_PERSONALIZATION"] = 2] = "DEV_ONBOARDING_STAGE_PERSONALIZATION";
+    DevOnboardingStage[DevOnboardingStage["DEV_ONBOARDING_STAGE_SELECT_SETUP_METHOD"] = 3] = "DEV_ONBOARDING_STAGE_SELECT_SETUP_METHOD";
+    DevOnboardingStage[DevOnboardingStage["DEV_ONBOARDING_STAGE_NEW_DEVICE"] = 4] = "DEV_ONBOARDING_STAGE_NEW_DEVICE";
+    DevOnboardingStage[DevOnboardingStage["DEV_ONBOARDING_STAGE_SELECT_RESTORE_METHOD"] = 5] = "DEV_ONBOARDING_STAGE_SELECT_RESTORE_METHOD";
+    DevOnboardingStage[DevOnboardingStage["DEV_ONBOARDING_STAGE_RESTORE_MNEMONIC"] = 6] = "DEV_ONBOARDING_STAGE_RESTORE_MNEMONIC";
+    DevOnboardingStage[DevOnboardingStage["DEV_ONBOARDING_STAGE_RESTORE_SEEDCARD"] = 7] = "DEV_ONBOARDING_STAGE_RESTORE_SEEDCARD";
+    DevOnboardingStage[DevOnboardingStage["DEV_ONBOARDING_STAGE_WALLET_READY"] = 8] = "DEV_ONBOARDING_STAGE_WALLET_READY";
+    DevOnboardingStage[DevOnboardingStage["DEV_ONBOARDING_STAGE_SEEDCARD_BACKUP_PROMPT"] = 9] = "DEV_ONBOARDING_STAGE_SEEDCARD_BACKUP_PROMPT";
+    DevOnboardingStage[DevOnboardingStage["DEV_ONBOARDING_STAGE_SELECT_SEEDCARD_BACKUP_METHOD"] = 10] = "DEV_ONBOARDING_STAGE_SELECT_SEEDCARD_BACKUP_METHOD";
+    DevOnboardingStage[DevOnboardingStage["DEV_ONBOARDING_STAGE_SEEDCARD_BACKUP"] = 11] = "DEV_ONBOARDING_STAGE_SEEDCARD_BACKUP";
+    DevOnboardingStage[DevOnboardingStage["DEV_ONBOARDING_STAGE_DONE"] = 12] = "DEV_ONBOARDING_STAGE_DONE";
+})(exports.DevOnboardingStage || (exports.DevOnboardingStage = {}));
 
 var messages = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -1619,12 +1956,15 @@ var messages = /*#__PURE__*/Object.freeze({
     get WallpaperTarget () { return exports.WallpaperTarget; },
     get MoneroNetworkType () { return exports.MoneroNetworkType; },
     get ViewTipType () { return exports.ViewTipType; },
-    get DevRebootType () { return exports.DevRebootType; },
+    get ViewSignLayout () { return exports.ViewSignLayout; },
+    get DeviceRebootType () { return exports.DeviceRebootType; },
+    get DeviceFirmwareTargetType () { return exports.DeviceFirmwareTargetType; },
+    get DeviceFirmwareUpdateTaskStatus () { return exports.DeviceFirmwareUpdateTaskStatus; },
+    get DeviceFactoryAck () { return exports.DeviceFactoryAck; },
     get DeviceType () { return exports.DeviceType; },
-    get DevSeType () { return exports.DevSeType; },
-    get DevSEState () { return exports.DevSEState; },
-    get DevFirmwareTargetType () { return exports.DevFirmwareTargetType; },
-    get OnboardingStep () { return exports.OnboardingStep; }
+    get DeviceSeType () { return exports.DeviceSeType; },
+    get DeviceSEState () { return exports.DeviceSEState; },
+    get DevOnboardingStage () { return exports.DevOnboardingStage; }
 });
 
 protobuf__namespace.util.Long = Long__default["default"];
@@ -1637,7 +1977,10 @@ var index = {
     ProtocolV2,
     PROTOCOL_V2_SYS_MESSAGE_THRESHOLD,
     ProtocolV2FrameAssembler,
+    ProtocolV2LinkManager,
+    ProtocolV2SequenceCursor,
     ProtocolV2Session,
+    ProtocolV2UsbTransportBase,
     bytesToHex,
     concatUint8Arrays,
     createMessageFromName,
@@ -1659,6 +2002,8 @@ exports.PROTOCOL_V1_MESSAGE_HEADER_SIZE = PROTOCOL_V1_MESSAGE_HEADER_SIZE;
 exports.PROTOCOL_V1_REPORT_ID = PROTOCOL_V1_REPORT_ID;
 exports.PROTOCOL_V1_USB_PACKET_SIZE = PROTOCOL_V1_USB_PACKET_SIZE;
 exports.PROTOCOL_V2_BLE_FILE_CHUNK_SIZE = PROTOCOL_V2_BLE_FILE_CHUNK_SIZE;
+exports.PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE = PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE;
+exports.PROTOCOL_V2_BLE_FRAME_MAX_BYTES = PROTOCOL_V2_BLE_FRAME_MAX_BYTES;
 exports.PROTOCOL_V2_CHANNEL_BLE_UART = PROTOCOL_V2_CHANNEL_BLE_UART;
 exports.PROTOCOL_V2_CHANNEL_SOCKET = PROTOCOL_V2_CHANNEL_SOCKET;
 exports.PROTOCOL_V2_CHANNEL_USB = PROTOCOL_V2_CHANNEL_USB;
@@ -1671,7 +2016,10 @@ exports.PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS = PROTOCOL_V2_WRITE_WATCHDOG_TIMEO
 exports.ProtocolV1 = ProtocolV1;
 exports.ProtocolV2 = ProtocolV2;
 exports.ProtocolV2FrameAssembler = ProtocolV2FrameAssembler;
+exports.ProtocolV2LinkManager = ProtocolV2LinkManager;
+exports.ProtocolV2SequenceCursor = ProtocolV2SequenceCursor;
 exports.ProtocolV2Session = ProtocolV2Session;
+exports.ProtocolV2UsbTransportBase = ProtocolV2UsbTransportBase;
 exports.bytesToHex = bytesToHex;
 exports.concatUint8Arrays = concatUint8Arrays;
 exports["default"] = index;