@onekeyfe/hd-transport 1.2.0-alpha.12 → 1.2.0-alpha.121

package/dist/index.js

@@ -140,7 +140,7 @@ function messageToJSON(Message, fields) {
             res[key] = field.resolvedType.valuesById[value];
         }
         else if (field.resolvedType.fields) {
-            res[key] = messageToJSON(value, field.resolvedType.fields);
+            res[key] = value == null ? null : messageToJSON(value, field.resolvedType.fields);
         }
         else {
             throw new Error(`case not handled: ${key}`);
@@ -200,7 +200,10 @@ function patch(Message, payload) {
         }
         if (field.repeated) {
             const RefMessage = Message.lookupTypeOrEnum(field.type);
-            patched[key] = value.map((v) => patch(RefMessage, v));
+            patched[key] =
+                RefMessage instanceof protobuf.Enum
+                    ? value.map((v) => transform(field.type, v))
+                    : value.map((v) => patch(RefMessage, v));
         }
         else if (typeof value === 'object' && value !== null) {
             const RefMessage = Message.lookupType(field.type);
@@ -267,9 +270,10 @@ const PROTOCOL_V1_CHUNK_PAYLOAD_SIZE = 63;
 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_FRAME_MAX_BYTES = 4200;
 const PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE = 4000;
 const PROTOCOL_V2_BLE_FILE_CHUNK_SIZE = 1800;
+const PROTOCOL_V2_BLE_FIRMWARE_FILE_CHUNK_SIZE = 1960;
 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;
@@ -277,6 +281,7 @@ const PROTOCOL_V2_CHANNEL_USB = 0;
 const PROTOCOL_V2_CHANNEL_BLE_UART = 1;
 const PROTOCOL_V2_CHANNEL_SOCKET = 2;
 const PROTOCOL_V2_PACKET_SRC_COMMAND = 0;
+const PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS = 5 * 60 * 1000;
 
 function encodeEnvelope(data, options) {
     const { addTrezorHeaders, chunked, messageTypeId } = options;
@@ -425,7 +430,7 @@ function encodeFrame(payload, packetSrc, router, seq) {
     const payloadLen = payload ? payload.length : 0;
     const frameLen = payloadLen + PROTO_HEAD_CRC_SIZE;
     if (frameLen > PROTOCOL_V2_FRAME_MAX_BYTES) {
-        throw new Error(`Protocol V2 frame too large: ${frameLen}`);
+        throw new Error(`Protocol V2 frame too large: ${frameLen} > ${PROTOCOL_V2_FRAME_MAX_BYTES}`);
     }
     const frame = new Uint8Array(frameLen);
     frame[0] = PROTO_HEAD_SOF;
@@ -450,7 +455,7 @@ function encodeProtobufFrame(messageTypeId, pbPayload, packetSrc, router, seq) {
     return encodeFrame(payload, packetSrc, router, seq);
 }
 
-function validateFrame(data) {
+function inspectFrameHeader(data) {
     if (data.length < PROTO_HEAD_CRC_SIZE) {
         throw new Error(`Protocol V2 frame too short: ${data.length} bytes`);
     }
@@ -458,8 +463,8 @@ function validateFrame(data) {
         throw new Error(`Invalid SOF byte: expected 0x5A, got 0x${data[0].toString(16).padStart(2, '0')}`);
     }
     const frameLen = data[1] + data[2] * 256;
-    if (data.length < frameLen) {
-        throw new Error(`Frame truncated: expected ${frameLen} bytes, got ${data.length}`);
+    if (data.length !== frameLen) {
+        throw new Error(`Protocol V2 frame length mismatch: expected ${frameLen} bytes, got ${data.length}`);
     }
     const expectedHeaderCrc = crc8(data, 3);
     if (data[3] !== expectedHeaderCrc) {
@@ -473,30 +478,54 @@ function validateFrame(data) {
             .toString(16)
             .padStart(2, '0')}, got 0x${data[frameLen - 1].toString(16).padStart(2, '0')}`);
     }
-    return frameLen;
+    const dataType = data[5] & 0x03;
+    const packetSrc = (data[5] >> 2) & 0x0f;
+    const seq = data[6];
+    if (seq === 0) {
+        throw new Error('Invalid Protocol V2 sequence: 0 is reserved');
+    }
+    return {
+        frameLen,
+        router: data[4],
+        packetSrc,
+        dataType,
+        seq,
+    };
 }
 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}`);
+    const header = inspectFrameHeader(data);
+    if (header.frameLen !== PROTO_HEAD_CRC_SIZE) {
+        throw new Error(`Invalid Protocol V2 ACK frame length: ${header.frameLen}`);
     }
     return true;
 }
 function decodeFrame(data) {
-    const frameLen = validateFrame(data);
-    const seq = data[6];
+    const { frameLen, router, packetSrc, dataType, seq } = inspectFrameHeader(data);
+    if (dataType !== PROTO_DATA_TYPE_PACKET) {
+        throw new Error(`Invalid Protocol V2 data type: expected packet, got ${dataType}`);
+    }
     const payloadData = data.slice(7, frameLen - 1);
     if (payloadData.length < 2) {
         throw new Error(`Protocol V2 payload too short (need >=2 bytes for messageTypeId)`);
     }
     const messageTypeId = payloadData[0] + payloadData[1] * 256;
     const pbPayload = payloadData.slice(2);
-    return { messageTypeId, pbPayload, seq };
+    return { messageTypeId, pbPayload, seq, router, packetSrc, dataType };
 }
 
+class ProtocolV2LinkError extends Error {
+    constructor(code, message, cause) {
+        super(message);
+        this.name = 'ProtocolV2LinkError';
+        this.code = code;
+        this.cause = cause;
+    }
+}
+const isProtocolV2LinkError = (error) => error instanceof ProtocolV2LinkError;
+
 function concatUint8Arrays(arrays) {
     const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
     const result = new Uint8Array(totalLength);
@@ -540,23 +569,23 @@ class ProtocolV2FrameAssembler {
             return undefined;
         if (this.buffer[0] !== PROTO_HEAD_SOF) {
             this.reset();
-            throw new Error('Invalid Protocol V2 SOF');
+            throw new ProtocolV2LinkError('frame', 'Invalid Protocol V2 SOF');
         }
         const expectedLen = this.buffer[1] + this.buffer[2] * 256;
         if (expectedLen < PROTO_HEAD_CRC_SIZE) {
             this.reset();
-            throw new Error(`Protocol V2 frame length too small: ${expectedLen}`);
+            throw new ProtocolV2LinkError('frame', `Protocol V2 frame length too small: ${expectedLen}`);
         }
         if (expectedLen > this.maxFrameBytes) {
             this.reset();
-            throw new Error(`Protocol V2 frame too large: ${expectedLen}`);
+            throw new ProtocolV2LinkError('frame', `Protocol V2 frame too large: ${expectedLen}`);
         }
         if (this.buffer.length < PROTO_PRE_HEAD_SIZE)
             return undefined;
         const expectedHeaderCrc = crc8(this.buffer, 3);
         if (this.buffer[3] !== expectedHeaderCrc) {
             this.reset();
-            throw new Error(`Protocol V2 header CRC mismatch: expected 0x${expectedHeaderCrc
+            throw new ProtocolV2LinkError('frame', `Protocol V2 header CRC mismatch: expected 0x${expectedHeaderCrc
                 .toString(16)
                 .padStart(2, '0')}`);
         }
@@ -568,6 +597,51 @@ class ProtocolV2FrameAssembler {
     }
 }
 
+const defaultWait = (timeoutMs) => new Promise(resolve => {
+    setTimeout(resolve, timeoutMs);
+});
+function writeProtocolV2BleFrame({ frame, packetCapacity, writePacket, assertActive, signal, abortMessage = 'Protocol V2 BLE write aborted', initialDelayMs = 0, burstSize, burstPauseMs = 0, flushDelayMs = 0, wait = defaultWait, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!Number.isInteger(packetCapacity) || packetCapacity <= 0) {
+            throw new Error('Protocol V2 BLE packet capacity must be a positive integer');
+        }
+        if (burstSize !== undefined && (!Number.isInteger(burstSize) || burstSize <= 0)) {
+            throw new Error('Protocol V2 BLE burst size must be a positive integer');
+        }
+        const assertWritable = () => {
+            assertActive === null || assertActive === void 0 ? void 0 : assertActive();
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                throw new Error(abortMessage);
+            }
+        };
+        if (frame.length > 0 && initialDelayMs > 0) {
+            assertWritable();
+            yield wait(initialDelayMs);
+            assertWritable();
+        }
+        let packetsWritten = 0;
+        for (let offset = 0; offset < frame.length; offset += packetCapacity) {
+            assertWritable();
+            const packet = frame.slice(offset, offset + packetCapacity);
+            yield writePacket(packet, packetsWritten);
+            packetsWritten += 1;
+            assertWritable();
+            const hasMorePackets = offset + packetCapacity < frame.length;
+            if (hasMorePackets &&
+                burstSize !== undefined &&
+                packetsWritten % burstSize === 0 &&
+                burstPauseMs > 0) {
+                yield wait(burstPauseMs);
+                assertWritable();
+            }
+        }
+        if (burstSize !== undefined && packetsWritten > burstSize && flushDelayMs > 0) {
+            yield wait(flushDelayMs);
+            assertWritable();
+        }
+    });
+}
+
 var protocolV2Codec = /*#__PURE__*/Object.freeze({
     __proto__: null,
     PROTO_HEAD_SOF: PROTO_HEAD_SOF,
@@ -582,13 +656,92 @@ var protocolV2Codec = /*#__PURE__*/Object.freeze({
     nextProtoSeq: nextProtoSeq,
     encodeFrame: encodeFrame,
     encodeProtobufFrame: encodeProtobufFrame,
+    inspectFrameHeader: inspectFrameHeader,
     isAckFrame: isAckFrame,
     decodeFrame: decodeFrame,
+    ProtocolV2LinkError: ProtocolV2LinkError,
+    isProtocolV2LinkError: isProtocolV2LinkError,
     concatUint8Arrays: concatUint8Arrays,
-    ProtocolV2FrameAssembler: ProtocolV2FrameAssembler
+    ProtocolV2FrameAssembler: ProtocolV2FrameAssembler,
+    writeProtocolV2BleFrame: writeProtocolV2BleFrame
 });
 
 const PROTOCOL_V2_SYS_MESSAGE_THRESHOLD = 60000;
+const LEGACY_PROTOCOL_V2_PROTOCOL_INFO = protobuf.Type.fromJSON('LegacyProtocolInfo', {
+    fields: {
+        version: {
+            rule: 'required',
+            type: 'uint32',
+            id: 1,
+        },
+        supported_messages: {
+            rule: 'repeated',
+            type: 'uint32',
+            id: 2,
+            options: {
+                packed: false,
+            },
+        },
+        protobuf_definition: {
+            type: 'string',
+            id: 3,
+        },
+    },
+});
+const decodeLegacyProtocolV2ProtocolInfo = (pbPayload) => {
+    var _a;
+    const byteBuffer = ByteBuffer__default["default"].wrap(Buffer.from(pbPayload));
+    const legacy = decode(LEGACY_PROTOCOL_V2_PROTOCOL_INFO, byteBuffer);
+    return {
+        version: legacy.version,
+        build_fingerprint: '',
+        supported_messages: (_a = legacy.supported_messages) !== null && _a !== void 0 ? _a : [],
+        protobuf_definition: null,
+    };
+};
+const isLegacyProtocolV2ProtocolInfoWireLayout = (pbPayload) => {
+    const reader = protobuf.Reader.create(pbPayload);
+    let hasVersion = false;
+    try {
+        while (reader.pos < reader.len) {
+            const tag = reader.uint32();
+            const fieldNumber = tag >>> 3;
+            const wireType = tag & 0x07;
+            if (fieldNumber === 1) {
+                if (wireType !== 0)
+                    return false;
+                hasVersion = true;
+            }
+            else if (fieldNumber === 2) {
+                if (wireType !== 0)
+                    return false;
+            }
+            else if (fieldNumber === 3) {
+                if (wireType !== 2)
+                    return false;
+            }
+            else {
+                return false;
+            }
+            reader.skipType(wireType);
+        }
+    }
+    catch (_a) {
+        return false;
+    }
+    return hasVersion;
+};
+const tryDecodeLegacyProtocolV2ProtocolInfo = (messageName, pbPayload) => {
+    if (messageName !== 'ProtocolInfo' || !isLegacyProtocolV2ProtocolInfoWireLayout(pbPayload)) {
+        return undefined;
+    }
+    try {
+        return decodeLegacyProtocolV2ProtocolInfo(pbPayload);
+    }
+    catch (_a) {
+        return undefined;
+    }
+};
 const resolveProtocolV2EncodeSchema = (name, schemas) => {
     try {
         schemas.protocolV2.lookupType(name);
@@ -634,6 +787,21 @@ const ProtocolV1 = {
 };
 const ProtocolV2 = {
     isAckFrame,
+    inspectFrameHeader,
+    inspectFrame(schemas, frame) {
+        const { messageTypeId, pbPayload, seq, router, packetSrc, dataType } = decodeFrame(frame);
+        const { messageName } = createProtocolV2MessageFromType(messageTypeId, schemas);
+        return {
+            messageName,
+            messageTypeId,
+            pbPayload,
+            seq,
+            router,
+            packetSrc,
+            dataType,
+            type: messageName,
+        };
+    },
     encodeFrame(schemas, name, data, options = {}) {
         const encodeMessages = resolveProtocolV2EncodeSchema(name, schemas);
         const { Message, messageTypeId } = createMessageFromName(encodeMessages, name);
@@ -644,10 +812,31 @@ const ProtocolV2 = {
         return encodeProtobufFrame(messageTypeId, pbBytes, options.packetSrc, options.router, options.seq);
     },
     decodeFrame(schemas, frame) {
-        const { messageTypeId, pbPayload, seq } = decodeFrame(frame);
-        const { Message, messageName } = createProtocolV2MessageFromType(messageTypeId, schemas);
+        const { messageTypeId, pbPayload, seq, messageName } = this.inspectFrame(schemas, frame);
+        const { Message } = createProtocolV2MessageFromType(messageTypeId, schemas);
         const rxByteBuffer = ByteBuffer__default["default"].wrap(Buffer.from(pbPayload));
-        const message = decode(Message, rxByteBuffer);
+        let message;
+        try {
+            message = decode(Message, rxByteBuffer);
+        }
+        catch (cause) {
+            const legacyProtocolInfo = tryDecodeLegacyProtocolV2ProtocolInfo(messageName, pbPayload);
+            if (legacyProtocolInfo) {
+                return {
+                    message: legacyProtocolInfo,
+                    messageName,
+                    messageTypeId,
+                    pbPayload,
+                    seq,
+                    type: messageName,
+                };
+            }
+            const error = new Error(`Protocol V2 protobuf decode failed for "${messageName}" ` +
+                `(${messageTypeId}, ${pbPayload.length}-byte payload); ` +
+                'the payload is malformed or incompatible with the active SDK schema.');
+            error.cause = cause;
+            throw error;
+        }
         return {
             message,
             messageName,
@@ -796,14 +985,27 @@ function bytesToHex(bytes) {
         .map(b => b.toString(16).padStart(2, '0'))
         .join('');
 }
-const HIGH_VOLUME_PROTOCOL_V2_CALLS = new Set([
+const REDUCED_DEBUG_PROTOCOL_V2_CALLS = new Set([
     ...LogBlockCommand,
     'FilesystemFileRead',
     'FileRead',
     'EmmcFileRead',
 ]);
 function shouldReduceProtocolV2Debug(name) {
-    return HIGH_VOLUME_PROTOCOL_V2_CALLS.has(name);
+    return REDUCED_DEBUG_PROTOCOL_V2_CALLS.has(name);
+}
+const HIGH_THROUGHPUT_PROTOCOL_V2_CALLS = new Set([
+    'FilesystemFileWrite',
+    'FileWrite',
+    'EmmcFileWrite',
+    'FirmwareUpload',
+    'ResourceAck',
+    'FilesystemFileRead',
+    'FileRead',
+    'EmmcFileRead',
+]);
+function isProtocolV2HighThroughputCall(name) {
+    return HIGH_THROUGHPUT_PROTOCOL_V2_CALLS.has(name);
 }
 const COMMON_TERMINAL_RESPONSE_TYPES = new Set([
     'Failure',
@@ -830,11 +1032,12 @@ function getErrorMessage(error) {
     }
     return String(error);
 }
-function withProtocolTimeout(promise, timeoutMs, createTimeoutError, onTimeout) {
+function withProtocolTimeout(promise, timeoutMs, createTimeoutError, onTimeout, abortSignal) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!timeoutMs)
             return promise;
         let timer;
+        let abortHandler;
         try {
             return yield Promise.race([
                 promise,
@@ -844,15 +1047,32 @@ function withProtocolTimeout(promise, timeoutMs, createTimeoutError, onTimeout)
                         reject(createTimeoutError());
                     }, timeoutMs);
                 }),
+                ...(abortSignal
+                    ? [
+                        new Promise((_, reject) => {
+                            abortHandler = () => {
+                                reject(new Error('Protocol V2 operation aborted'));
+                            };
+                            if (abortSignal.aborted) {
+                                abortHandler();
+                            }
+                            else {
+                                abortSignal.addEventListener('abort', abortHandler, { once: true });
+                            }
+                        }),
+                    ]
+                    : []),
             ]);
         }
         finally {
             if (timer)
                 clearTimeout(timer);
+            if (abortHandler) {
+                abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.removeEventListener('abort', abortHandler);
+            }
         }
     });
 }
-const PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS = 0;
 class ProtocolV2Session {
     constructor(options) {
         var _a;
@@ -867,16 +1087,18 @@ class ProtocolV2Session {
         return result;
     }
     executeCall(name, data, callOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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);
-            const callContext = {
-                messageName: name,
-                timeoutMs: callOptions.timeoutMs,
-                highVolume: shouldReduceDebug,
-                generation,
-            };
-            yield (prepareCall === null || prepareCall === void 0 ? void 0 : prepareCall(callContext));
+        const { schemas, router, packetSrc = PROTOCOL_V2_PACKET_SRC_COMMAND, maxFrameBytes, prepareCall, writeFrame, readFrame, logger, logPrefix = 'ProtocolV2', createTimeoutError, generation = 0, } = this.options;
+        const timeoutMs = callOptions.timeoutMs && callOptions.timeoutMs > 0
+            ? callOptions.timeoutMs
+            : PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS;
+        const abortController = new AbortController();
+        const shouldReduceDebug = shouldReduceProtocolV2Debug(name);
+        const baseCallContext = Object.assign(Object.assign({ messageName: name, timeoutMs, highThroughput: isProtocolV2HighThroughputCall(name) }, (callOptions.writeWithResponse === undefined
+            ? {}
+            : { writeWithResponse: callOptions.writeWithResponse })), { generation, signal: abortController.signal });
+        const runCall = () => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            yield (prepareCall === null || prepareCall === void 0 ? void 0 : prepareCall(baseCallContext));
             const protoSeq = this.sequenceCursor.next();
             const frame = ProtocolV2.encodeFrame(schemas, name, data, {
                 packetSrc,
@@ -886,40 +1108,79 @@ class ProtocolV2Session {
             if (maxFrameBytes !== undefined && frame.length > maxFrameBytes) {
                 throw new Error(`Protocol V2 frame too large for transport: ${frame.length} > ${maxFrameBytes}`);
             }
-            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 _a, _b, _c, _d;
-                while (!cancellation.cancelled) {
-                    const rxFrame = yield readFrame(callContext);
-                    if (cancellation.cancelled) {
-                        break;
+            const writeStartedAt = Date.now();
+            yield writeFrame(frame, baseCallContext);
+            try {
+                (_a = callOptions.onWriteCompleted) === null || _a === void 0 ? void 0 : _a.call(callOptions, {
+                    elapsedMs: Math.max(Date.now() - writeStartedAt, 0),
+                    frameBytes: frame.byteLength,
+                });
+            }
+            catch (error) {
+                (_b = logger === null || logger === void 0 ? void 0 : logger.error) === null || _b === void 0 ? void 0 : _b.call(logger, `${logPrefix} write metrics callback failed: ${String(error)}`);
+            }
+            if (callOptions.returnAfterWrite) {
+                return { type: 'WriteCompleted', message: {} };
+            }
+            while (!abortController.signal.aborted) {
+                const rxFrame = yield readFrame(baseCallContext);
+                if (abortController.signal.aborted)
+                    break;
+                let header;
+                try {
+                    header = ProtocolV2.inspectFrameHeader(rxFrame);
+                }
+                catch (cause) {
+                    throw new ProtocolV2LinkError('frame', `Protocol V2 frame validation failed: ${getErrorMessage(cause)}`, cause);
+                }
+                if (header.router !== router) {
+                    throw new ProtocolV2LinkError('router', `Protocol V2 router mismatch: expected ${router}, got ${header.router}`);
+                }
+                if (header.packetSrc !== packetSrc) {
+                    throw new ProtocolV2LinkError('packet-source', `Protocol V2 packet source mismatch: expected ${packetSrc}, got ${header.packetSrc}`);
+                }
+                let isAck;
+                try {
+                    isAck = ProtocolV2.isAckFrame(rxFrame);
+                }
+                catch (cause) {
+                    throw new ProtocolV2LinkError('frame', `Protocol V2 ACK validation failed: ${getErrorMessage(cause)}`, cause);
+                }
+                if (isAck) {
+                    if (header.seq !== protoSeq) {
+                        throw new ProtocolV2LinkError('ack-sequence', `Protocol V2 ACK sequence mismatch: expected ${protoSeq}, got ${header.seq}`);
                     }
-                    const isAck = ProtocolV2.isAckFrame(rxFrame);
-                    if (!isAck) {
-                        const decoded = ProtocolV2.decodeFrame(schemas, rxFrame);
-                        const response = call(decoded);
-                        if ((_a = callOptions.intermediateTypes) === null || _a === void 0 ? void 0 : _a.includes(response.type)) {
-                            (_b = callOptions.onIntermediateResponse) === null || _b === void 0 ? void 0 : _b.call(callOptions, response);
-                        }
-                        else if (isExpectedTerminalResponse(response, callOptions.expectedTypes)) {
-                            return response;
-                        }
-                        else if (!shouldReduceDebug) {
-                            (_c = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _c === void 0 ? void 0 : _c.call(logger, `[${logPrefix}] skip unexpected response for ${name}: expected=${(_d = callOptions.expectedTypes) === null || _d === void 0 ? void 0 : _d.join('|')} got=${response.type}`);
-                        }
+                }
+                else {
+                    let decoded;
+                    try {
+                        decoded = ProtocolV2.decodeFrame(schemas, rxFrame);
+                    }
+                    catch (cause) {
+                        throw new ProtocolV2LinkError('frame', `Protocol V2 frame decode failed: ${getErrorMessage(cause)}`, cause);
+                    }
+                    if (this.lastResponseSequence === decoded.seq) {
+                        throw new ProtocolV2LinkError('response-sequence', `Protocol V2 duplicate response sequence: ${decoded.seq}`);
+                    }
+                    this.lastResponseSequence = decoded.seq;
+                    const response = call(decoded);
+                    if ((_c = callOptions.intermediateTypes) === null || _c === void 0 ? void 0 : _c.includes(response.type)) {
+                        (_d = callOptions.onIntermediateResponse) === null || _d === void 0 ? void 0 : _d.call(callOptions, response);
+                    }
+                    else if (isExpectedTerminalResponse(response, callOptions.expectedTypes)) {
+                        return response;
+                    }
+                    else if (!shouldReduceDebug) {
+                        (_e = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _e === void 0 ? void 0 : _e.call(logger, `[${logPrefix}] skip unexpected response for ${name}: expected=${(_f = callOptions.expectedTypes) === null || _f === void 0 ? void 0 : _f.join('|')} got=${response.type}`);
                     }
                 }
-                throw new Error(`Protocol V2 read loop cancelled after timeout for ${name}`);
-            });
-            return withProtocolTimeout(readResponse(), callOptions.timeoutMs, () => {
-                var _a;
-                return createTimeoutError
-                    ? createTimeoutError(name, (_a = callOptions.timeoutMs) !== null && _a !== void 0 ? _a : 0)
-                    : new Error(`Protocol V2 response timeout after ${callOptions.timeoutMs}ms for ${name}`);
-            }, () => {
-                cancellation.cancelled = true;
-            });
+            }
+            throw new Error(`Protocol V2 read loop cancelled after timeout for ${name}`);
+        });
+        return withProtocolTimeout(runCall(), timeoutMs, () => createTimeoutError
+            ? createTimeoutError(name, timeoutMs)
+            : new Error(`Protocol V2 response timeout after ${timeoutMs}ms for ${name}`), () => {
+            abortController.abort();
         });
     }
 }
@@ -929,7 +1190,10 @@ function probeProtocolV2({ call, timeoutMs, logger, logPrefix = 'ProtocolV2', on
         let probeError;
         try {
             yield (onBeforeProbe === null || onBeforeProbe === void 0 ? void 0 : onBeforeProbe());
-            const response = yield call('Ping', { message: 'protocol-v2-probe' }, { timeoutMs, expectedTypes: ['Success'] });
+            const response = yield call('Ping', { message: 'protocol-v2-probe' }, {
+                timeoutMs,
+                expectedTypes: ['Success'],
+            });
             if (response.type === 'Success') {
                 return true;
             }
@@ -949,12 +1213,19 @@ class ProtocolV2LinkManager {
         this.links = new Map();
         this.sequences = new Map();
         this.callQueues = new Map();
+        this.generations = new Map();
+        this.invalidationReasons = new Map();
+        this.invalidations = 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();
+        var _a, _b;
+        const generation = (_a = this.generations.get(key)) !== null && _a !== void 0 ? _a : 0;
+        const run = () => {
+            this.assertCallGeneration(key, generation);
+            return this.executeCall(key, createAdapter, name, data, options);
+        };
+        const previous = (_b = this.callQueues.get(key)) !== null && _b !== void 0 ? _b : Promise.resolve();
         const result = previous.then(run, run);
         const queue = result.catch(() => undefined);
         this.callQueues.set(key, queue);
@@ -964,20 +1235,44 @@ class ProtocolV2LinkManager {
         return result;
     }
     invalidateLink(key, reason) {
-        var _a, _b;
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            const generation = ((_a = this.generations.get(key)) !== null && _a !== void 0 ? _a : 0) + 1;
+            this.generations.set(key, generation);
+            this.invalidationReasons.set(key, { generation, reason });
+            const pendingInvalidation = this.invalidations.get(key);
             const link = this.links.get(key);
-            if (!link)
+            if (!link) {
+                yield pendingInvalidation;
                 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));
+            const invalidation = (() => __awaiter(this, void 0, void 0, function* () {
+                var _b, _c;
+                yield (pendingInvalidation === null || pendingInvalidation === void 0 ? void 0 : pendingInvalidation.catch(() => undefined));
+                yield link.adapter.reset(reason);
+                yield ((_c = (_b = this.options).onLinkInvalidated) === null || _c === void 0 ? void 0 : _c.call(_b, key, reason));
+            }))();
+            this.invalidations.set(key, invalidation);
+            try {
+                yield invalidation;
+            }
+            finally {
+                if (this.invalidations.get(key) === invalidation) {
+                    this.invalidations.delete(key);
+                }
+            }
         });
     }
     invalidateAllLinks(reason) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all(Array.from(this.links.keys(), key => this.invalidateLink(key, reason)));
+            const keys = new Set([
+                ...this.links.keys(),
+                ...this.callQueues.keys(),
+                ...this.invalidations.keys(),
+            ]);
+            yield Promise.all(Array.from(keys, key => this.invalidateLink(key, reason)));
         });
     }
     dispose(reason) {
@@ -985,6 +1280,7 @@ class ProtocolV2LinkManager {
             yield this.invalidateAllLinks(reason);
             this.sequences.clear();
             this.callQueues.clear();
+            this.invalidations.clear();
         });
     }
     getOrCreateLink(key, createAdapter) {
@@ -1052,6 +1348,17 @@ class ProtocolV2LinkManager {
             this.callQueues.delete(key);
         }
     }
+    assertCallGeneration(key, generation) {
+        var _a;
+        const currentGeneration = (_a = this.generations.get(key)) !== null && _a !== void 0 ? _a : 0;
+        if (currentGeneration === generation)
+            return;
+        const invalidation = this.invalidationReasons.get(key);
+        const reason = (invalidation === null || invalidation === void 0 ? void 0 : invalidation.generation) === currentGeneration
+            ? invalidation.reason
+            : 'Protocol V2 link generation changed';
+        throw new ProtocolV2LinkError('generation', reason);
+    }
 }
 
 class ProtocolV2UsbTransportBase {
@@ -1062,7 +1369,7 @@ class ProtocolV2UsbTransportBase {
         this.protocolV2UsbOptions = options;
         this.protocolV2UsbLinks = new ProtocolV2LinkManager({
             getSchemas: () => this.getProtocolV2UsbSchemas(),
-            classifyError: () => 'link-fatal',
+            classifyError: error => (isProtocolV2LinkError(error) ? 'link-fatal' : 'recoverable'),
             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();
@@ -1112,10 +1419,10 @@ class ProtocolV2UsbTransportBase {
         }
         const assertCurrentGeneration = () => {
             if (cancellation.reason) {
-                throw new Error(cancellation.reason);
+                throw new ProtocolV2LinkError('generation', cancellation.reason);
             }
             if (this.protocolV2UsbGenerations.get(key) !== generation) {
-                throw new Error('Protocol V2 USB connection generation changed');
+                throw new ProtocolV2LinkError('generation', 'Protocol V2 USB connection generation changed');
             }
         };
         return {
@@ -1124,11 +1431,15 @@ class ProtocolV2UsbTransportBase {
             generation,
             prepareCall: () => {
                 assertCurrentGeneration();
-                this.getProtocolV2UsbAssembler(key).reset();
             },
             writeFrame: (frame, context) => __awaiter(this, void 0, void 0, function* () {
                 assertCurrentGeneration();
-                yield this.writeProtocolV2UsbPacket(key, frame, context);
+                try {
+                    yield this.writeProtocolV2UsbPacket(key, frame, context);
+                }
+                catch (error) {
+                    throw this.createProtocolV2UsbIoError('write', error);
+                }
                 assertCurrentGeneration();
             }),
             readFrame: (context) => __awaiter(this, void 0, void 0, function* () {
@@ -1136,13 +1447,15 @@ class ProtocolV2UsbTransportBase {
                 const assembler = this.getProtocolV2UsbAssembler(key);
                 let frame = assembler.push(new Uint8Array(0));
                 while (!frame) {
-                    const packetRead = this.readProtocolV2UsbPacket(key, context).then(packet => ({
-                        packet,
-                    }));
+                    const packetRead = this.readProtocolV2UsbPacket(key, context)
+                        .then(packet => ({ packet }))
+                        .catch(error => {
+                        throw this.createProtocolV2UsbIoError('read', error);
+                    });
                     const cancelled = cancellation.promise.then(reason => ({ reason }));
                     const result = yield Promise.race([packetRead, cancelled]);
                     if ('reason' in result) {
-                        throw new Error(result.reason);
+                        throw new ProtocolV2LinkError('generation', result.reason);
                     }
                     assertCurrentGeneration();
                     frame = assembler.push(result.packet);
@@ -1183,8 +1496,17 @@ class ProtocolV2UsbTransportBase {
         };
         return cancellation;
     }
+    createProtocolV2UsbIoError(operation, error) {
+        if (isProtocolV2LinkError(error))
+            return error;
+        return new ProtocolV2LinkError('io', `Protocol V2 USB ${operation} failed: ${getErrorMessage(error) || 'unknown error'}`, error);
+    }
 }
 
+const TRANSPORT_EVENT = {
+    DEVICE_DISCONNECT: 'transport-device-disconnect',
+};
+
 exports.AptosTransactionType = void 0;
 (function (AptosTransactionType) {
     AptosTransactionType[AptosTransactionType["STANDARD"] = 0] = "STANDARD";
@@ -1431,6 +1753,24 @@ exports.EthereumDataType = void 0;
     EthereumDataType[EthereumDataType["ARRAY"] = 7] = "ARRAY";
     EthereumDataType[EthereumDataType["STRUCT"] = 8] = "STRUCT";
 })(exports.EthereumDataType || (exports.EthereumDataType = {}));
+exports.Enum_KaspaInputScriptType = void 0;
+(function (Enum_KaspaInputScriptType) {
+    Enum_KaspaInputScriptType[Enum_KaspaInputScriptType["KASPA_SPEND_P2PK_SCHNORR"] = 0] = "KASPA_SPEND_P2PK_SCHNORR";
+    Enum_KaspaInputScriptType[Enum_KaspaInputScriptType["KASPA_SPEND_P2PK_ECDSA"] = 1] = "KASPA_SPEND_P2PK_ECDSA";
+})(exports.Enum_KaspaInputScriptType || (exports.Enum_KaspaInputScriptType = {}));
+exports.Enum_KaspaOutputScriptType = void 0;
+(function (Enum_KaspaOutputScriptType) {
+    Enum_KaspaOutputScriptType[Enum_KaspaOutputScriptType["KASPA_PAYTOADDRESS"] = 0] = "KASPA_PAYTOADDRESS";
+    Enum_KaspaOutputScriptType[Enum_KaspaOutputScriptType["KASPA_PAYTOCHANGE"] = 1] = "KASPA_PAYTOCHANGE";
+})(exports.Enum_KaspaOutputScriptType || (exports.Enum_KaspaOutputScriptType = {}));
+exports.Enum_KaspaRequestType = void 0;
+(function (Enum_KaspaRequestType) {
+    Enum_KaspaRequestType[Enum_KaspaRequestType["KASPA_TX_INPUT"] = 0] = "KASPA_TX_INPUT";
+    Enum_KaspaRequestType[Enum_KaspaRequestType["KASPA_TX_OUTPUT"] = 1] = "KASPA_TX_OUTPUT";
+    Enum_KaspaRequestType[Enum_KaspaRequestType["KASPA_TX_PAYLOAD"] = 2] = "KASPA_TX_PAYLOAD";
+    Enum_KaspaRequestType[Enum_KaspaRequestType["KASPA_TX_FINISHED"] = 3] = "KASPA_TX_FINISHED";
+    Enum_KaspaRequestType[Enum_KaspaRequestType["KASPA_TX_PREV_META"] = 4] = "KASPA_TX_PREV_META";
+})(exports.Enum_KaspaRequestType || (exports.Enum_KaspaRequestType = {}));
 exports.Enum_BackupType = void 0;
 (function (Enum_BackupType) {
     Enum_BackupType[Enum_BackupType["Bip39"] = 0] = "Bip39";
@@ -1624,11 +1964,6 @@ exports.CommandFlags = void 0;
     CommandFlags[CommandFlags["Default"] = 0] = "Default";
     CommandFlags[CommandFlags["Factory_Only"] = 1] = "Factory_Only";
 })(exports.CommandFlags || (exports.CommandFlags = {}));
-exports.WallpaperTarget = void 0;
-(function (WallpaperTarget) {
-    WallpaperTarget[WallpaperTarget["Home"] = 0] = "Home";
-    WallpaperTarget[WallpaperTarget["Lock"] = 1] = "Lock";
-})(exports.WallpaperTarget || (exports.WallpaperTarget = {}));
 exports.MoneroNetworkType = void 0;
 (function (MoneroNetworkType) {
     MoneroNetworkType[MoneroNetworkType["MAINNET"] = 0] = "MAINNET";
@@ -1636,19 +1971,18 @@ exports.MoneroNetworkType = void 0;
     MoneroNetworkType[MoneroNetworkType["STAGENET"] = 2] = "STAGENET";
     MoneroNetworkType[MoneroNetworkType["FAKECHAIN"] = 3] = "FAKECHAIN";
 })(exports.MoneroNetworkType || (exports.MoneroNetworkType = {}));
-exports.ViewTipType = void 0;
-(function (ViewTipType) {
-    ViewTipType[ViewTipType["Default"] = 0] = "Default";
-    ViewTipType[ViewTipType["Highlight"] = 1] = "Highlight";
-    ViewTipType[ViewTipType["Recommend"] = 2] = "Recommend";
-    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.UiAnimationType = void 0;
+(function (UiAnimationType) {
+    UiAnimationType[UiAnimationType["Unknown"] = 0] = "Unknown";
+    UiAnimationType[UiAnimationType["Signing"] = 1] = "Signing";
+})(exports.UiAnimationType || (exports.UiAnimationType = {}));
+exports.UiAnimationCommand = void 0;
+(function (UiAnimationCommand) {
+    UiAnimationCommand[UiAnimationCommand["CommandUnknown"] = 0] = "CommandUnknown";
+    UiAnimationCommand[UiAnimationCommand["Start"] = 1] = "Start";
+    UiAnimationCommand[UiAnimationCommand["Stop"] = 2] = "Stop";
+    UiAnimationCommand[UiAnimationCommand["Refresh"] = 3] = "Refresh";
+})(exports.UiAnimationCommand || (exports.UiAnimationCommand = {}));
 exports.DeviceErrorCode = void 0;
 (function (DeviceErrorCode) {
     DeviceErrorCode[DeviceErrorCode["DeviceError_None"] = 0] = "DeviceError_None";
@@ -1675,6 +2009,11 @@ exports.DeviceSettingsPage = void 0;
     DeviceSettingsPage[DeviceSettingsPage["DevicePassphrase"] = 2] = "DevicePassphrase";
     DeviceSettingsPage[DeviceSettingsPage["DeviceAirgap"] = 3] = "DeviceAirgap";
 })(exports.DeviceSettingsPage || (exports.DeviceSettingsPage = {}));
+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.DeviceFirmwareTargetType = void 0;
 (function (DeviceFirmwareTargetType) {
     DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_INVALID"] = 0] = "FW_MGMT_TARGET_INVALID";
@@ -1703,11 +2042,6 @@ exports.DeviceFirmwareUpdateTaskStatus = void 0;
     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";
@@ -1730,22 +2064,116 @@ 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 = {}));
+exports.DeviceSessionErrorCode = void 0;
+(function (DeviceSessionErrorCode) {
+    DeviceSessionErrorCode[DeviceSessionErrorCode["DeviceSessionError_None"] = 0] = "DeviceSessionError_None";
+    DeviceSessionErrorCode[DeviceSessionErrorCode["DeviceSessionError_UserCancelled"] = 1] = "DeviceSessionError_UserCancelled";
+    DeviceSessionErrorCode[DeviceSessionErrorCode["DeviceSessionError_InvalidSession"] = 2] = "DeviceSessionError_InvalidSession";
+    DeviceSessionErrorCode[DeviceSessionErrorCode["DeviceSessionError_AttachPinUnavailable"] = 3] = "DeviceSessionError_AttachPinUnavailable";
+    DeviceSessionErrorCode[DeviceSessionErrorCode["DeviceSessionError_PassphraseDisabled"] = 4] = "DeviceSessionError_PassphraseDisabled";
+    DeviceSessionErrorCode[DeviceSessionErrorCode["DeviceSessionError_Busy"] = 5] = "DeviceSessionError_Busy";
+})(exports.DeviceSessionErrorCode || (exports.DeviceSessionErrorCode = {}));
+exports.DeviceSessionSeedDomain = void 0;
+(function (DeviceSessionSeedDomain) {
+    DeviceSessionSeedDomain[DeviceSessionSeedDomain["SeedDomain_Standard"] = 1] = "SeedDomain_Standard";
+    DeviceSessionSeedDomain[DeviceSessionSeedDomain["SeedDomain_Cardano"] = 2] = "SeedDomain_Cardano";
+})(exports.DeviceSessionSeedDomain || (exports.DeviceSessionSeedDomain = {}));
+exports.DeviceSessionPinType = void 0;
+(function (DeviceSessionPinType) {
+    DeviceSessionPinType[DeviceSessionPinType["Any"] = 1] = "Any";
+    DeviceSessionPinType[DeviceSessionPinType["Main"] = 2] = "Main";
+    DeviceSessionPinType[DeviceSessionPinType["AttachToPin"] = 3] = "AttachToPin";
+})(exports.DeviceSessionPinType || (exports.DeviceSessionPinType = {}));
+exports.DeviceSessionAskPin_FailureSubCodes = void 0;
+(function (DeviceSessionAskPin_FailureSubCodes) {
+    DeviceSessionAskPin_FailureSubCodes[DeviceSessionAskPin_FailureSubCodes["UserCancel"] = 1] = "UserCancel";
+})(exports.DeviceSessionAskPin_FailureSubCodes || (exports.DeviceSessionAskPin_FailureSubCodes = {}));
+exports.OnboardingStep = void 0;
+(function (OnboardingStep) {
+    OnboardingStep[OnboardingStep["ONBOARDING_STEP_UNKNOWN"] = 0] = "ONBOARDING_STEP_UNKNOWN";
+    OnboardingStep[OnboardingStep["ONBOARDING_STEP_CHECKING"] = 1] = "ONBOARDING_STEP_CHECKING";
+    OnboardingStep[OnboardingStep["ONBOARDING_STEP_PERSONALIZATION"] = 2] = "ONBOARDING_STEP_PERSONALIZATION";
+    OnboardingStep[OnboardingStep["ONBOARDING_STEP_PIN"] = 3] = "ONBOARDING_STEP_PIN";
+    OnboardingStep[OnboardingStep["ONBOARDING_STEP_SETUP"] = 4] = "ONBOARDING_STEP_SETUP";
+    OnboardingStep[OnboardingStep["ONBOARDING_STEP_DONE"] = 5] = "ONBOARDING_STEP_DONE";
+})(exports.OnboardingStep || (exports.OnboardingStep = {}));
+exports.OnboardingPhase = void 0;
+(function (OnboardingPhase) {
+    OnboardingPhase[OnboardingPhase["ONBOARDING_PHASE_UNKNOWN"] = 0] = "ONBOARDING_PHASE_UNKNOWN";
+    OnboardingPhase[OnboardingPhase["ONBOARDING_PHASE_SAFETY_CHECK"] = 1] = "ONBOARDING_PHASE_SAFETY_CHECK";
+    OnboardingPhase[OnboardingPhase["ONBOARDING_PHASE_PIN_SETUP"] = 2] = "ONBOARDING_PHASE_PIN_SETUP";
+    OnboardingPhase[OnboardingPhase["ONBOARDING_PHASE_FINGERPRINT_SETUP"] = 3] = "ONBOARDING_PHASE_FINGERPRINT_SETUP";
+    OnboardingPhase[OnboardingPhase["ONBOARDING_PHASE_SETUP_CHOICE"] = 4] = "ONBOARDING_PHASE_SETUP_CHOICE";
+    OnboardingPhase[OnboardingPhase["ONBOARDING_PHASE_WALLET_CREATE_START"] = 5] = "ONBOARDING_PHASE_WALLET_CREATE_START";
+    OnboardingPhase[OnboardingPhase["ONBOARDING_PHASE_RECOVERY_PHRASE_VIEW"] = 6] = "ONBOARDING_PHASE_RECOVERY_PHRASE_VIEW";
+    OnboardingPhase[OnboardingPhase["ONBOARDING_PHASE_RECOVERY_PHRASE_CONFIRM"] = 7] = "ONBOARDING_PHASE_RECOVERY_PHRASE_CONFIRM";
+    OnboardingPhase[OnboardingPhase["ONBOARDING_PHASE_RESTORE_METHOD_CHOICE"] = 8] = "ONBOARDING_PHASE_RESTORE_METHOD_CHOICE";
+    OnboardingPhase[OnboardingPhase["ONBOARDING_PHASE_RECOVERY_PHRASE_RESTORE"] = 9] = "ONBOARDING_PHASE_RECOVERY_PHRASE_RESTORE";
+    OnboardingPhase[OnboardingPhase["ONBOARDING_PHASE_SEEDCARD_RESTORE"] = 10] = "ONBOARDING_PHASE_SEEDCARD_RESTORE";
+    OnboardingPhase[OnboardingPhase["ONBOARDING_PHASE_WALLET_READY"] = 11] = "ONBOARDING_PHASE_WALLET_READY";
+    OnboardingPhase[OnboardingPhase["ONBOARDING_PHASE_SEEDCARD_BACKUP_PROMPT"] = 12] = "ONBOARDING_PHASE_SEEDCARD_BACKUP_PROMPT";
+    OnboardingPhase[OnboardingPhase["ONBOARDING_PHASE_SEEDCARD_BACKUP"] = 13] = "ONBOARDING_PHASE_SEEDCARD_BACKUP";
+})(exports.OnboardingPhase || (exports.OnboardingPhase = {}));
+exports.OnboardingSetupKind = void 0;
+(function (OnboardingSetupKind) {
+    OnboardingSetupKind[OnboardingSetupKind["ONBOARDING_SETUP_KIND_UNKNOWN"] = 0] = "ONBOARDING_SETUP_KIND_UNKNOWN";
+    OnboardingSetupKind[OnboardingSetupKind["ONBOARDING_SETUP_KIND_CHOICE"] = 1] = "ONBOARDING_SETUP_KIND_CHOICE";
+    OnboardingSetupKind[OnboardingSetupKind["ONBOARDING_SETUP_KIND_CREATE"] = 2] = "ONBOARDING_SETUP_KIND_CREATE";
+    OnboardingSetupKind[OnboardingSetupKind["ONBOARDING_SETUP_KIND_RESTORE"] = 3] = "ONBOARDING_SETUP_KIND_RESTORE";
+})(exports.OnboardingSetupKind || (exports.OnboardingSetupKind = {}));
+exports.OnboardingSetupMethod = void 0;
+(function (OnboardingSetupMethod) {
+    OnboardingSetupMethod[OnboardingSetupMethod["ONBOARDING_SETUP_METHOD_UNKNOWN"] = 0] = "ONBOARDING_SETUP_METHOD_UNKNOWN";
+    OnboardingSetupMethod[OnboardingSetupMethod["ONBOARDING_SETUP_METHOD_RECOVERY_PHRASE"] = 1] = "ONBOARDING_SETUP_METHOD_RECOVERY_PHRASE";
+    OnboardingSetupMethod[OnboardingSetupMethod["ONBOARDING_SETUP_METHOD_SEEDCARD"] = 2] = "ONBOARDING_SETUP_METHOD_SEEDCARD";
+})(exports.OnboardingSetupMethod || (exports.OnboardingSetupMethod = {}));
+exports.ViewTipType = void 0;
+(function (ViewTipType) {
+    ViewTipType[ViewTipType["Default"] = 0] = "Default";
+    ViewTipType[ViewTipType["Highlight"] = 1] = "Highlight";
+    ViewTipType[ViewTipType["Recommend"] = 2] = "Recommend";
+    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";
+    ViewSignLayout[ViewSignLayout["LayoutFinalConfirm"] = 2] = "LayoutFinalConfirm";
+    ViewSignLayout[ViewSignLayout["Layout7702"] = 3] = "Layout7702";
+    ViewSignLayout[ViewSignLayout["LayoutFlat"] = 4] = "LayoutFlat";
+    ViewSignLayout[ViewSignLayout["LayoutEthApprove"] = 5] = "LayoutEthApprove";
+})(exports.ViewSignLayout || (exports.ViewSignLayout = {}));
+exports.ProtocolV2FailureType = void 0;
+(function (ProtocolV2FailureType) {
+    ProtocolV2FailureType[ProtocolV2FailureType["Failure_InvalidMessage"] = 1] = "Failure_InvalidMessage";
+    ProtocolV2FailureType[ProtocolV2FailureType["Failure_UndefinedError"] = 2] = "Failure_UndefinedError";
+    ProtocolV2FailureType[ProtocolV2FailureType["Failure_UsageError"] = 3] = "Failure_UsageError";
+    ProtocolV2FailureType[ProtocolV2FailureType["Failure_DataError"] = 4] = "Failure_DataError";
+    ProtocolV2FailureType[ProtocolV2FailureType["Failure_ProcessError"] = 5] = "Failure_ProcessError";
+})(exports.ProtocolV2FailureType || (exports.ProtocolV2FailureType = {}));
+exports.Enum_ProtocolV2Capability = void 0;
+(function (Enum_ProtocolV2Capability) {
+    Enum_ProtocolV2Capability[Enum_ProtocolV2Capability["Capability_Bitcoin"] = 1] = "Capability_Bitcoin";
+    Enum_ProtocolV2Capability[Enum_ProtocolV2Capability["Capability_Bitcoin_like"] = 2] = "Capability_Bitcoin_like";
+    Enum_ProtocolV2Capability[Enum_ProtocolV2Capability["Capability_Binance"] = 3] = "Capability_Binance";
+    Enum_ProtocolV2Capability[Enum_ProtocolV2Capability["Capability_Cardano"] = 4] = "Capability_Cardano";
+    Enum_ProtocolV2Capability[Enum_ProtocolV2Capability["Capability_Crypto"] = 5] = "Capability_Crypto";
+    Enum_ProtocolV2Capability[Enum_ProtocolV2Capability["Capability_EOS"] = 6] = "Capability_EOS";
+    Enum_ProtocolV2Capability[Enum_ProtocolV2Capability["Capability_Ethereum"] = 7] = "Capability_Ethereum";
+    Enum_ProtocolV2Capability[Enum_ProtocolV2Capability["Capability_Lisk"] = 8] = "Capability_Lisk";
+    Enum_ProtocolV2Capability[Enum_ProtocolV2Capability["Capability_Monero"] = 9] = "Capability_Monero";
+    Enum_ProtocolV2Capability[Enum_ProtocolV2Capability["Capability_NEM"] = 10] = "Capability_NEM";
+    Enum_ProtocolV2Capability[Enum_ProtocolV2Capability["Capability_Ripple"] = 11] = "Capability_Ripple";
+    Enum_ProtocolV2Capability[Enum_ProtocolV2Capability["Capability_Stellar"] = 12] = "Capability_Stellar";
+    Enum_ProtocolV2Capability[Enum_ProtocolV2Capability["Capability_Tezos"] = 13] = "Capability_Tezos";
+    Enum_ProtocolV2Capability[Enum_ProtocolV2Capability["Capability_U2F"] = 14] = "Capability_U2F";
+    Enum_ProtocolV2Capability[Enum_ProtocolV2Capability["Capability_Shamir"] = 15] = "Capability_Shamir";
+    Enum_ProtocolV2Capability[Enum_ProtocolV2Capability["Capability_ShamirGroups"] = 16] = "Capability_ShamirGroups";
+    Enum_ProtocolV2Capability[Enum_ProtocolV2Capability["Capability_PassphraseEntry"] = 17] = "Capability_PassphraseEntry";
+    Enum_ProtocolV2Capability[Enum_ProtocolV2Capability["Capability_AttachToPin"] = 18] = "Capability_AttachToPin";
+    Enum_ProtocolV2Capability[Enum_ProtocolV2Capability["Capability_EthereumTypedData"] = 1000] = "Capability_EthereumTypedData";
+})(exports.Enum_ProtocolV2Capability || (exports.Enum_ProtocolV2Capability = {}));
 
 var messages = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -1778,6 +2206,9 @@ var messages = /*#__PURE__*/Object.freeze({
     get EthereumGnosisSafeTxOperation () { return exports.EthereumGnosisSafeTxOperation; },
     get EthereumDataTypeOneKey () { return exports.EthereumDataTypeOneKey; },
     get EthereumDataType () { return exports.EthereumDataType; },
+    get Enum_KaspaInputScriptType () { return exports.Enum_KaspaInputScriptType; },
+    get Enum_KaspaOutputScriptType () { return exports.Enum_KaspaOutputScriptType; },
+    get Enum_KaspaRequestType () { return exports.Enum_KaspaRequestType; },
     get Enum_BackupType () { return exports.Enum_BackupType; },
     get Enum_SafetyCheckLevel () { return exports.Enum_SafetyCheckLevel; },
     get OneKeyDeviceType () { return exports.OneKeyDeviceType; },
@@ -1809,22 +2240,114 @@ var messages = /*#__PURE__*/Object.freeze({
     get TronResourceCode () { return exports.TronResourceCode; },
     get TronMessageType () { return exports.TronMessageType; },
     get CommandFlags () { return exports.CommandFlags; },
-    get WallpaperTarget () { return exports.WallpaperTarget; },
     get MoneroNetworkType () { return exports.MoneroNetworkType; },
-    get ViewTipType () { return exports.ViewTipType; },
-    get ViewSignLayout () { return exports.ViewSignLayout; },
+    get UiAnimationType () { return exports.UiAnimationType; },
+    get UiAnimationCommand () { return exports.UiAnimationCommand; },
     get DeviceErrorCode () { return exports.DeviceErrorCode; },
     get DeviceRebootType () { return exports.DeviceRebootType; },
     get DeviceSettingsPage () { return exports.DeviceSettingsPage; },
+    get DeviceFactoryAck () { return exports.DeviceFactoryAck; },
     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 DevOnboardingStage () { return exports.DevOnboardingStage; }
+    get DeviceSessionErrorCode () { return exports.DeviceSessionErrorCode; },
+    get DeviceSessionSeedDomain () { return exports.DeviceSessionSeedDomain; },
+    get DeviceSessionPinType () { return exports.DeviceSessionPinType; },
+    get DeviceSessionAskPin_FailureSubCodes () { return exports.DeviceSessionAskPin_FailureSubCodes; },
+    get OnboardingStep () { return exports.OnboardingStep; },
+    get OnboardingPhase () { return exports.OnboardingPhase; },
+    get OnboardingSetupKind () { return exports.OnboardingSetupKind; },
+    get OnboardingSetupMethod () { return exports.OnboardingSetupMethod; },
+    get ViewTipType () { return exports.ViewTipType; },
+    get ViewSignLayout () { return exports.ViewSignLayout; },
+    get ProtocolV2FailureType () { return exports.ProtocolV2FailureType; },
+    get Enum_ProtocolV2Capability () { return exports.Enum_ProtocolV2Capability; }
 });
 
+const REDACTED = '[REDACTED]';
+const SENSITIVE_LOG_KEYS = new Set([
+    'accesstoken',
+    'address',
+    'apikey',
+    'connectid',
+    'devicestate',
+    'deviceid',
+    'entropy',
+    'expectedpassphrasestate',
+    'mnemonic',
+    'passphrase',
+    'passphrasestate',
+    'password',
+    'pin',
+    'privatekey',
+    'publickey',
+    'seed',
+    'serialnumber',
+    'session',
+    'sessionid',
+    'signature',
+    'token',
+    'uuid',
+    'walletsessionid',
+    'xprv',
+    'xpub',
+]);
+const normalizeLogKey = (key) => key.replace(/[_-]/g, '').toLowerCase();
+const isSensitiveLogKey = (key) => {
+    const normalizedKey = normalizeLogKey(key);
+    return (SENSITIVE_LOG_KEYS.has(normalizedKey) ||
+        normalizedKey.endsWith('address') ||
+        normalizedKey.endsWith('privatekey') ||
+        normalizedKey.endsWith('publickey') ||
+        normalizedKey.endsWith('signature'));
+};
+const isSigningMessage = (messageName) => Boolean(messageName && /(?:sign|txack|transaction)/i.test(messageName));
+const redactLogValue = (value, seen) => {
+    if (ArrayBuffer.isView(value)) {
+        return `[BINARY:${value.byteLength}]`;
+    }
+    if (value instanceof ArrayBuffer) {
+        return `[BINARY:${value.byteLength}]`;
+    }
+    if (Array.isArray(value)) {
+        return value.map(item => redactLogValue(item, seen));
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    if (seen.has(value)) {
+        return '[CIRCULAR]';
+    }
+    seen.add(value);
+    const redacted = Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        key,
+        isSensitiveLogKey(key) && item !== null && item !== undefined
+            ? REDACTED
+            : redactLogValue(item, seen),
+    ]));
+    seen.delete(value);
+    return redacted;
+};
+function getSafeTransportLogPayload(value, messageName) {
+    if (isSigningMessage(messageName)) {
+        return REDACTED;
+    }
+    return redactLogValue(value, new WeakSet());
+}
+function createTransportCallLog(name, protocol, data) {
+    return {
+        name,
+        protocol,
+        request: getSafeTransportLogPayload(data, name),
+    };
+}
+const HIGH_VOLUME_CALLS = new Set(['FileWrite', 'FilesystemFileWrite', 'EmmcFileWrite']);
+function shouldSuppressHighVolumeCallLog(name) {
+    return HIGH_VOLUME_CALLS.has(name);
+}
+
 protobuf__namespace.util.Long = Long__default["default"];
 protobuf__namespace.configure();
 var index = {
@@ -1861,29 +2384,38 @@ 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_FIRMWARE_FILE_CHUNK_SIZE = PROTOCOL_V2_BLE_FIRMWARE_FILE_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;
+exports.PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS = PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS;
 exports.PROTOCOL_V2_FILE_CHUNK_SIZE = PROTOCOL_V2_FILE_CHUNK_SIZE;
 exports.PROTOCOL_V2_FRAME_MAX_BYTES = PROTOCOL_V2_FRAME_MAX_BYTES;
 exports.PROTOCOL_V2_PACKET_SRC_COMMAND = PROTOCOL_V2_PACKET_SRC_COMMAND;
 exports.PROTOCOL_V2_SYS_MESSAGE_THRESHOLD = PROTOCOL_V2_SYS_MESSAGE_THRESHOLD;
 exports.PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE = PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
-exports.PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS = PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS;
 exports.ProtocolV1 = ProtocolV1;
 exports.ProtocolV2 = ProtocolV2;
 exports.ProtocolV2FrameAssembler = ProtocolV2FrameAssembler;
+exports.ProtocolV2LinkError = ProtocolV2LinkError;
 exports.ProtocolV2LinkManager = ProtocolV2LinkManager;
 exports.ProtocolV2SequenceCursor = ProtocolV2SequenceCursor;
 exports.ProtocolV2Session = ProtocolV2Session;
 exports.ProtocolV2UsbTransportBase = ProtocolV2UsbTransportBase;
+exports.TRANSPORT_EVENT = TRANSPORT_EVENT;
 exports.bytesToHex = bytesToHex;
 exports.concatUint8Arrays = concatUint8Arrays;
+exports.createTransportCallLog = createTransportCallLog;
 exports["default"] = index;
 exports.getErrorMessage = getErrorMessage;
+exports.getSafeTransportLogPayload = getSafeTransportLogPayload;
 exports.hexToBytes = hexToBytes;
+exports.isProtocolV2HighThroughputCall = isProtocolV2HighThroughputCall;
+exports.isProtocolV2LinkError = isProtocolV2LinkError;
 exports.probeProtocolV2 = probeProtocolV2;
 exports.protocolV1 = index$1;
 exports.protocolV2 = protocolV2Codec;
+exports.shouldSuppressHighVolumeCallLog = shouldSuppressHighVolumeCallLog;
 exports.withProtocolTimeout = withProtocolTimeout;
+exports.writeProtocolV2BleFrame = writeProtocolV2BleFrame;