@onekeyfe/hd-transport 1.2.0-alpha.8 → 1.2.0-alpha.9

package/dist/index.js

@@ -270,6 +270,8 @@ 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 = 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;
@@ -381,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,
@@ -462,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`);
     }
@@ -485,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) {
@@ -587,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
@@ -643,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);
@@ -705,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) {
@@ -959,9 +991,10 @@ function withProtocolTimeout(promise, timeoutMs, createTimeoutError, onTimeout)
 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);
@@ -972,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);
+                    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 (isExpectedTerminalResponse(response, callOptions.expectedTypes)) {
-                        return response;
-                    }
-                    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}`);
@@ -1057,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";
@@ -1516,6 +1808,11 @@ exports.ViewTipType = void 0;
     ViewTipType[ViewTipType["Warning"] = 3] = "Warning";
     ViewTipType[ViewTipType["Danger"] = 4] = "Danger";
 })(exports.ViewTipType || (exports.ViewTipType = {}));
+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";
@@ -1577,6 +1874,22 @@ exports.DeviceSEState = void 0;
     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,
@@ -1643,13 +1956,15 @@ var messages = /*#__PURE__*/Object.freeze({
     get WallpaperTarget () { return exports.WallpaperTarget; },
     get MoneroNetworkType () { return exports.MoneroNetworkType; },
     get ViewTipType () { return exports.ViewTipType; },
+    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 DeviceSeType () { return exports.DeviceSeType; },
-    get DeviceSEState () { return exports.DeviceSEState; }
+    get DeviceSEState () { return exports.DeviceSEState; },
+    get DevOnboardingStage () { return exports.DevOnboardingStage; }
 });
 
 protobuf__namespace.util.Long = Long__default["default"];
@@ -1662,7 +1977,10 @@ var index = {
     ProtocolV2,
     PROTOCOL_V2_SYS_MESSAGE_THRESHOLD,
     ProtocolV2FrameAssembler,
+    ProtocolV2LinkManager,
+    ProtocolV2SequenceCursor,
     ProtocolV2Session,
+    ProtocolV2UsbTransportBase,
     bytesToHex,
     concatUint8Arrays,
     createMessageFromName,
@@ -1684,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;
@@ -1696,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;

package/dist/protocols/index.d.ts

@@ -2,6 +2,7 @@
 import ByteBuffer from 'bytebuffer';
 import { encodeEnvelopeMessage } from './v1/packets';
 import { decodeMessage as decodeV1Message } from './v1/receive';
+import { isAckFrame } from './v2';
 import type { Root } from 'protobufjs/light';
 import type { ProtocolV2DebugLogger } from './v2';
 export declare const PROTOCOL_V2_SYS_MESSAGE_THRESHOLD = 60000;
@@ -29,6 +30,7 @@ export declare const ProtocolV1: {
     decodeMessage: typeof decodeV1Message;
 };
 export declare const ProtocolV2: {
+    isAckFrame: typeof isAckFrame;
     encodeFrame(schemas: ProtocolV2Schemas, name: string, data: Record<string, unknown>, options?: ProtocolV2FrameOptions): Uint8Array;
     decodeFrame(schemas: ProtocolV2Schemas, frame: Uint8Array, options?: Pick<ProtocolV2FrameOptions, 'logger' | 'logPrefix' | 'context'>): {
         message: {

package/dist/protocols/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/protocols/index.ts"],"names":[],"mappings":";AAAA,OAAO,UAAU,MAAM,YAAY,CAAC;AAEpC,OAAO,EAAE,qBAAqB,EAA+C,MAAM,cAAc,CAAC;AAElG,OAAO,EAAE,aAAa,IAAI,eAAe,EAAE,MAAM,cAAc,CAAC;AAMhE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,MAAM,CAAC;AAElD,eAAO,MAAM,iCAAiC,QAAQ,CAAC;AAEvD,KAAK,iBAAiB,GAAG;IACvB,UAAU,EAAE,IAAI,CAAC;IACjB,UAAU,EAAE,IAAI,CAAC;CAClB,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,qBAAqB,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAsCF,eAAO,MAAM,UAAU;;;;;;;;;;CAOtB,CAAC;AAEF,eAAO,MAAM,UAAU;yBAEV,iBAAiB,QACpB,MAAM,QACN,OAAO,MAAM,EAAE,OAAO,CAAC,YACpB,sBAAsB;yBAkCtB,iBAAiB,SACnB,UAAU,YACR,KAAK,sBAAsB,EAAE,QAAQ,GAAG,WAAW,GAAG,SAAS,CAAC;;;;;;;;;;CA4B5E,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/protocols/index.ts"],"names":[],"mappings":";AAAA,OAAO,UAAU,MAAM,YAAY,CAAC;AAEpC,OAAO,EAAE,qBAAqB,EAA+C,MAAM,cAAc,CAAC;AAElG,OAAO,EAAE,aAAa,IAAI,eAAe,EAAE,MAAM,cAAc,CAAC;AAIhE,OAAO,EAAqD,UAAU,EAAE,MAAM,MAAM,CAAC;AAErF,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,MAAM,CAAC;AAElD,eAAO,MAAM,iCAAiC,QAAQ,CAAC;AAEvD,KAAK,iBAAiB,GAAG;IACvB,UAAU,EAAE,IAAI,CAAC;IACjB,UAAU,EAAE,IAAI,CAAC;CAClB,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,qBAAqB,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAsCF,eAAO,MAAM,UAAU;;;;;;;;;;CAOtB,CAAC;AAEF,eAAO,MAAM,UAAU;;yBAIV,iBAAiB,QACpB,MAAM,QACN,OAAO,MAAM,EAAE,OAAO,CAAC,YACpB,sBAAsB;yBAkCtB,iBAAiB,SACnB,UAAU,YACR,KAAK,sBAAsB,EAAE,QAAQ,GAAG,WAAW,GAAG,SAAS,CAAC;;;;;;;;;;CA4B5E,CAAC"}

package/dist/protocols/v2/constants.d.ts

@@ -4,4 +4,5 @@ export declare const PROTO_HEAD_CRC_SIZE = 8;
 export declare const CRC8_INIT = 48;
 export declare const PACKET_SIZE = 4096;
 export declare const PROTO_DATA_TYPE_PACKET = 0;
+export declare const PROTO_DATA_TYPE_ACK = 1;
 //# sourceMappingURL=constants.d.ts.map

package/dist/protocols/v2/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/protocols/v2/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,KAAO,CAAC;AACnC,eAAO,MAAM,mBAAmB,IAAI,CAAC;AACrC,eAAO,MAAM,mBAAmB,IAAI,CAAC;AACrC,eAAO,MAAM,SAAS,KAAO,CAAC;AAC9B,eAAO,MAAM,WAAW,OAAO,CAAC;AAChC,eAAO,MAAM,sBAAsB,IAAI,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/protocols/v2/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,KAAO,CAAC;AACnC,eAAO,MAAM,mBAAmB,IAAI,CAAC;AACrC,eAAO,MAAM,mBAAmB,IAAI,CAAC;AACrC,eAAO,MAAM,SAAS,KAAO,CAAC;AAC9B,eAAO,MAAM,WAAW,OAAO,CAAC;AAChC,eAAO,MAAM,sBAAsB,IAAI,CAAC;AACxC,eAAO,MAAM,mBAAmB,IAAI,CAAC"}

package/dist/protocols/v2/decode.d.ts

@@ -4,5 +4,6 @@ export interface ProtoV2Frame {
     pbPayload: Uint8Array;
     seq: number;
 }
+export declare function isAckFrame(data: Uint8Array): boolean;
 export declare function decodeFrame(data: Uint8Array, debugOptions?: ProtocolV2FrameDebugOptions): ProtoV2Frame;
 //# sourceMappingURL=decode.d.ts.map

package/dist/protocols/v2/decode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../../src/protocols/v2/decode.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,SAAS,CAAC;AAE3D,MAAM,WAAW,YAAY;IAE3B,aAAa,EAAE,MAAM,CAAC;IAEtB,SAAS,EAAE,UAAU,CAAC;IAEtB,GAAG,EAAE,MAAM,CAAC;CACb;AAYD,wBAAgB,WAAW,CACzB,IAAI,EAAE,UAAU,EAChB,YAAY,CAAC,EAAE,2BAA2B,GACzC,YAAY,CA+Dd"}
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../../src/protocols/v2/decode.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,SAAS,CAAC;AAE3D,MAAM,WAAW,YAAY;IAE3B,aAAa,EAAE,MAAM,CAAC;IAEtB,SAAS,EAAE,UAAU,CAAC;IAEtB,GAAG,EAAE,MAAM,CAAC;CACb;AAwCD,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAWpD;AAYD,wBAAgB,WAAW,CACzB,IAAI,EAAE,UAAU,EAChB,YAAY,CAAC,EAAE,2BAA2B,GACzC,YAAY,CA+Bd"}

package/dist/protocols/v2/link-manager.d.ts

@@ -0,0 +1,35 @@
+import type { MessageFromOneKey, TransportCallOptions } from '../../types';
+import type { ProtocolV2CallContext, ProtocolV2Schemas, ProtocolV2SessionOptions } from './session';
+export type ProtocolV2LinkErrorClassification = 'link-fatal' | 'recoverable';
+export interface ProtocolV2LinkAdapter {
+    router: number;
+    maxFrameBytes?: number;
+    generation: number;
+    prepareCall(context: ProtocolV2CallContext): Promise<void> | void;
+    writeFrame(frame: Uint8Array, context: ProtocolV2CallContext): Promise<void>;
+    readFrame(context: ProtocolV2CallContext): Promise<Uint8Array>;
+    reset(reason: string): Promise<void> | void;
+    logger?: ProtocolV2SessionOptions['logger'];
+    logPrefix?: string;
+    createTimeoutError?: ProtocolV2SessionOptions['createTimeoutError'];
+}
+export type ProtocolV2LinkManagerOptions<Key> = {
+    getSchemas: () => ProtocolV2Schemas;
+    classifyError: (error: unknown) => ProtocolV2LinkErrorClassification;
+    onLinkInvalidated?: (key: Key, reason: string) => Promise<void> | void;
+};
+export declare class ProtocolV2LinkManager<Key> {
+    private readonly links;
+    private readonly sequences;
+    private readonly callQueues;
+    private readonly options;
+    constructor(options: ProtocolV2LinkManagerOptions<Key>);
+    call(key: Key, createAdapter: () => ProtocolV2LinkAdapter, name: string, data: Record<string, unknown>, options?: TransportCallOptions): Promise<MessageFromOneKey>;
+    invalidateLink(key: Key, reason: string): Promise<void>;
+    invalidateAllLinks(reason: string): Promise<void>;
+    dispose(reason: string): Promise<void>;
+    private getOrCreateLink;
+    private executeCall;
+    private clearSettledCallQueue;
+}
+//# sourceMappingURL=link-manager.d.ts.map

package/dist/protocols/v2/link-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link-manager.d.ts","sourceRoot":"","sources":["../../../src/protocols/v2/link-manager.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAC3E,OAAO,KAAK,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAEpG,MAAM,MAAM,iCAAiC,GAAG,YAAY,GAAG,aAAa,CAAC;AAE7E,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAClE,UAAU,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7E,SAAS,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC/D,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC5C,MAAM,CAAC,EAAE,wBAAwB,CAAC,QAAQ,CAAC,CAAC;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kBAAkB,CAAC,EAAE,wBAAwB,CAAC,oBAAoB,CAAC,CAAC;CACrE;AAED,MAAM,MAAM,4BAA4B,CAAC,GAAG,IAAI;IAC9C,UAAU,EAAE,MAAM,iBAAiB,CAAC;IACpC,aAAa,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,iCAAiC,CAAC;IACrE,iBAAiB,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACxE,CAAC;AAUF,qBAAa,qBAAqB,CAAC,GAAG;IACpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkC;IAExD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA4C;IAEtE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoC;IAE/D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoC;gBAEhD,OAAO,EAAE,4BAA4B,CAAC,GAAG,CAAC;IAItD,IAAI,CACF,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,MAAM,qBAAqB,EAC1C,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,iBAAiB,CAAC;IAevB,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAUvD,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjD,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAM5C,OAAO,CAAC,eAAe;YA+CT,WAAW;IAkBzB,OAAO,CAAC,qBAAqB;CAK9B"}

package/dist/protocols/v2/sequence-cursor.d.ts

@@ -0,0 +1,5 @@
+export declare class ProtocolV2SequenceCursor {
+    private current;
+    next(): number;
+}
+//# sourceMappingURL=sequence-cursor.d.ts.map

package/dist/protocols/v2/sequence-cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequence-cursor.d.ts","sourceRoot":"","sources":["../../../src/protocols/v2/sequence-cursor.ts"],"names":[],"mappings":"AAEA,qBAAa,wBAAwB;IACnC,OAAO,CAAC,OAAO,CAAK;IAEpB,IAAI,IAAI,MAAM;CAIf"}