@onekeyfe/hd-transport 1.1.27 → 1.2.0-alpha.0

package/dist/index.js

@@ -28,7 +28,7 @@ function _interopNamespace(e) {
 }
 
 var protobuf__namespace = /*#__PURE__*/_interopNamespace(protobuf);
-var Long__namespace = /*#__PURE__*/_interopNamespace(Long);
+var Long__default = /*#__PURE__*/_interopDefaultLegacy(Long);
 var ByteBuffer__default = /*#__PURE__*/_interopDefaultLegacy(ByteBuffer);
 
 /******************************************************************************
@@ -58,6 +58,16 @@ function __rest(s, e) {
     return t;
 }
 
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
 typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
@@ -103,6 +113,12 @@ function messageToJSON(Message, fields) {
     Object.keys(fields).forEach(key => {
         const field = fields[key];
         const value = message[key];
+        if (value == null) {
+            if (field.optional) {
+                res[key] = null;
+            }
+            return;
+        }
         if (field.repeated) {
             if (isPrimitiveField(field.type)) {
                 res[key] = value.map((v) => transform$1(field, v));
@@ -132,7 +148,7 @@ function messageToJSON(Message, fields) {
     });
     return res;
 }
-const decode$1 = (Message, data) => {
+const decode = (Message, data) => {
     const buff = data.toBuffer();
     const a = new Uint8Array(buff);
     let decoded;
@@ -200,7 +216,7 @@ function patch(Message, payload) {
     });
     return patched;
 }
-const encode$1 = (Message, data) => {
+const encode = (Message, data) => {
     const payload = patch(Message, data);
     const message = Message.fromObject(payload);
     const buffer = Message.encode(message).finish();
@@ -219,13 +235,16 @@ function parseConfigure(data) {
 const createMessageFromName = (messages, name) => {
     const Message = messages.lookupType(name);
     const MessageType = messages.lookupEnum('MessageType');
-    let messageType = MessageType.values[`MessageType_${name}`];
-    if (!messageType && Message.options) {
-        messageType = Message.options['(wire_type)'];
+    let messageTypeId = MessageType.values[`MessageType_${name}`];
+    if (messageTypeId == null && Message.options) {
+        messageTypeId = Message.options['(wire_type)'];
+    }
+    if (!Number.isInteger(messageTypeId)) {
+        throw new Error(`MessageType for "${name}" is not defined in protobuf schema`);
     }
     return {
         Message,
-        messageType,
+        messageTypeId,
     };
 };
 const createMessageFromType = (messages, typeId) => {
@@ -238,55 +257,31 @@ const createMessageFromType = (messages, typeId) => {
     };
 };
 
-const MESSAGE_TOP_CHAR = 0x003f;
-const MESSAGE_HEADER_BYTE = 0x23;
-const HEADER_SIZE = 1 + 1 + 4 + 2;
-const BUFFER_SIZE = 63;
-const COMMON_HEADER_SIZE = 6;
+const PROTOCOL_V1_REPORT_ID = 0x3f;
+const PROTOCOL_V1_HEADER_BYTE = 0x23;
+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_WEBUSB_FILE_CHUNK_SIZE = 4096;
+const PROTOCOL_V2_BLE_FILE_CHUNK_SIZE = 1800;
+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;
+const PROTOCOL_V2_CHANNEL_SOCKET = 2;
+const PROTOCOL_V2_PACKET_SRC_COMMAND = 0;
 
-const readHeader = (buffer) => {
-    const typeId = buffer.readUint16();
-    const length = buffer.readUint32();
-    return { typeId, length };
-};
-const readHeaderChunked = (buffer) => {
-    const sharp1 = buffer.readByte();
-    const sharp2 = buffer.readByte();
-    const typeId = buffer.readUint16();
-    const length = buffer.readUint32();
-    return { sharp1, sharp2, typeId, length };
-};
-const decode = (byteBuffer) => {
-    const { typeId } = readHeader(byteBuffer);
-    return {
-        typeId,
-        buffer: byteBuffer,
-    };
-};
-const decodeChunked = (bytes) => {
-    const byteBuffer = ByteBuffer__default["default"].wrap(bytes, undefined, undefined, true);
-    const { sharp1, sharp2, typeId, length } = readHeaderChunked(byteBuffer);
-    if (sharp1 !== MESSAGE_HEADER_BYTE || sharp2 !== MESSAGE_HEADER_BYTE) {
-        throw new Error("Didn't receive expected header signature.");
-    }
-    return { length, typeId, restBuffer: byteBuffer };
-};
-
-var decodeProtocol = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    decode: decode,
-    decodeChunked: decodeChunked
-});
-
-function encode(data, options) {
-    const { addTrezorHeaders, chunked, messageType } = options;
-    const fullSize = (addTrezorHeaders ? HEADER_SIZE : HEADER_SIZE - 2) + data.limit;
+function encodeEnvelope(data, options) {
+    const { addTrezorHeaders, chunked, messageTypeId } = options;
+    const fullSize = (addTrezorHeaders ? PROTOCOL_V1_ENVELOPE_HEADER_SIZE : PROTOCOL_V1_ENVELOPE_HEADER_SIZE - 2) +
+        Number(data.limit);
     const encodedByteBuffer = new ByteBuffer__default["default"](fullSize);
     if (addTrezorHeaders) {
-        encodedByteBuffer.writeByte(MESSAGE_HEADER_BYTE);
-        encodedByteBuffer.writeByte(MESSAGE_HEADER_BYTE);
+        encodedByteBuffer.writeByte(PROTOCOL_V1_HEADER_BYTE);
+        encodedByteBuffer.writeByte(PROTOCOL_V1_HEADER_BYTE);
     }
-    encodedByteBuffer.writeUint16(messageType);
+    encodedByteBuffer.writeUint16(messageTypeId);
     encodedByteBuffer.writeUint32(data.limit);
     encodedByteBuffer.append(data.buffer);
     encodedByteBuffer.reset();
@@ -294,7 +289,7 @@ function encode(data, options) {
         return encodedByteBuffer;
     }
     const result = [];
-    const size = BUFFER_SIZE;
+    const size = PROTOCOL_V1_CHUNK_PAYLOAD_SIZE;
     const count = Math.floor((encodedByteBuffer.limit - 1) / size) + 1 || 1;
     for (let i = 0; i < count; i++) {
         const start = i * size;
@@ -306,30 +301,30 @@ function encode(data, options) {
     return result;
 }
 
-function buildOne(messages, name, data) {
-    const { Message, messageType } = createMessageFromName(messages, name);
-    const buffer = encode$1(Message, data);
-    return encode(buffer, {
+function encodeEnvelopeMessage(messages, name, data) {
+    const { Message, messageTypeId } = createMessageFromName(messages, name);
+    const buffer = encode(Message, data);
+    return encodeEnvelope(buffer, {
         addTrezorHeaders: false,
         chunked: false,
-        messageType,
+        messageTypeId,
     });
 }
-const buildEncodeBuffers = (messages, name, data) => {
-    const { Message, messageType } = createMessageFromName(messages, name);
-    const buffer = encode$1(Message, data);
-    return encode(buffer, {
+const encodeMessageChunks = (messages, name, data) => {
+    const { Message, messageTypeId } = createMessageFromName(messages, name);
+    const buffer = encode(Message, data);
+    return encodeEnvelope(buffer, {
         addTrezorHeaders: true,
         chunked: true,
-        messageType,
+        messageTypeId,
     });
 };
-const buildBuffers = (messages, name, data) => {
-    const encodeBuffers = buildEncodeBuffers(messages, name, data);
+const encodeTransportPackets = (messages, name, data) => {
+    const encodeBuffers = encodeMessageChunks(messages, name, data);
     const outBuffers = [];
     for (const buf of encodeBuffers) {
-        const chunkBuffer = new ByteBuffer__default["default"](BUFFER_SIZE + 1);
-        chunkBuffer.writeByte(MESSAGE_TOP_CHAR);
+        const chunkBuffer = new ByteBuffer__default["default"](PROTOCOL_V1_CHUNK_PAYLOAD_SIZE + 1);
+        chunkBuffer.writeByte(PROTOCOL_V1_REPORT_ID);
         chunkBuffer.append(buf);
         chunkBuffer.reset();
         outBuffers.push(chunkBuffer);
@@ -337,17 +332,374 @@ const buildBuffers = (messages, name, data) => {
     return outBuffers;
 };
 
-function receiveOne(messages, data) {
+const readHeader = (buffer) => {
+    const typeId = buffer.readUint16();
+    const length = buffer.readUint32();
+    return { typeId, length };
+};
+const readHeaderChunked = (buffer) => {
+    const sharp1 = buffer.readByte();
+    const sharp2 = buffer.readByte();
+    const typeId = buffer.readUint16();
+    const length = buffer.readUint32();
+    return { sharp1, sharp2, typeId, length };
+};
+const decodeEnvelope = (byteBuffer) => {
+    const { typeId } = readHeader(byteBuffer);
+    return {
+        typeId,
+        buffer: byteBuffer,
+    };
+};
+const decodeFirstChunk = (bytes) => {
+    const byteBuffer = ByteBuffer__default["default"].wrap(bytes, undefined, undefined, true);
+    const { sharp1, sharp2, typeId, length } = readHeaderChunked(byteBuffer);
+    if (sharp1 !== PROTOCOL_V1_HEADER_BYTE || sharp2 !== PROTOCOL_V1_HEADER_BYTE) {
+        throw new Error("Didn't receive expected header signature.");
+    }
+    return { length, typeId, restBuffer: byteBuffer };
+};
+
+function decodeMessage(messages, data) {
     const bytebuffer = ByteBuffer__default["default"].wrap(data, 'hex');
-    const { typeId, buffer } = decode(bytebuffer);
+    const { typeId, buffer } = decodeEnvelope(bytebuffer);
     const { Message, messageName } = createMessageFromType(messages, typeId);
-    const message = decode$1(Message, buffer);
+    const message = decode(Message, buffer);
     return {
         message,
         type: messageName,
     };
 }
 
+const PROTO_HEAD_SOF = 0x5a;
+const PROTO_PRE_HEAD_SIZE = 4;
+const PROTO_HEAD_CRC_SIZE = 8;
+const CRC8_INIT = 0x30;
+const PACKET_SIZE = 4096;
+const PROTO_DATA_TYPE_PACKET = 0;
+
+const CRC8_TABLE = new Uint8Array([
+    0x00, 0x5e, 0xbc, 0xe2, 0x61, 0x3f, 0xdd, 0x83, 0xc2, 0x9c, 0x7e, 0x20, 0xa3, 0xfd, 0x1f, 0x41,
+    0x9d, 0xc3, 0x21, 0x7f, 0xfc, 0xa2, 0x40, 0x1e, 0x5f, 0x01, 0xe3, 0xbd, 0x3e, 0x60, 0x82, 0xdc,
+    0x23, 0x7d, 0x9f, 0xc1, 0x42, 0x1c, 0xfe, 0xa0, 0xe1, 0xbf, 0x5d, 0x03, 0x80, 0xde, 0x3c, 0x62,
+    0xbe, 0xe0, 0x02, 0x5c, 0xdf, 0x81, 0x63, 0x3d, 0x7c, 0x22, 0xc0, 0x9e, 0x1d, 0x43, 0xa1, 0xff,
+    0x46, 0x18, 0xfa, 0xa4, 0x27, 0x79, 0x9b, 0xc5, 0x84, 0xda, 0x38, 0x66, 0xe5, 0xbb, 0x59, 0x07,
+    0xdb, 0x85, 0x67, 0x39, 0xba, 0xe4, 0x06, 0x58, 0x19, 0x47, 0xa5, 0xfb, 0x78, 0x26, 0xc4, 0x9a,
+    0x65, 0x3b, 0xd9, 0x87, 0x04, 0x5a, 0xb8, 0xe6, 0xa7, 0xf9, 0x1b, 0x45, 0xc6, 0x98, 0x7a, 0x24,
+    0xf8, 0xa6, 0x44, 0x1a, 0x99, 0xc7, 0x25, 0x7b, 0x3a, 0x64, 0x86, 0xd8, 0x5b, 0x05, 0xe7, 0xb9,
+    0x8c, 0xd2, 0x30, 0x6e, 0xed, 0xb3, 0x51, 0x0f, 0x4e, 0x10, 0xf2, 0xac, 0x2f, 0x71, 0x93, 0xcd,
+    0x11, 0x4f, 0xad, 0xf3, 0x70, 0x2e, 0xcc, 0x92, 0xd3, 0x8d, 0x6f, 0x31, 0xb2, 0xec, 0x0e, 0x50,
+    0xaf, 0xf1, 0x13, 0x4d, 0xce, 0x90, 0x72, 0x2c, 0x6d, 0x33, 0xd1, 0x8f, 0x0c, 0x52, 0xb0, 0xee,
+    0x32, 0x6c, 0x8e, 0xd0, 0x53, 0x0d, 0xef, 0xb1, 0xf0, 0xae, 0x4c, 0x12, 0x91, 0xcf, 0x2d, 0x73,
+    0xca, 0x94, 0x76, 0x28, 0xab, 0xf5, 0x17, 0x49, 0x08, 0x56, 0xb4, 0xea, 0x69, 0x37, 0xd5, 0x8b,
+    0x57, 0x09, 0xeb, 0xb5, 0x36, 0x68, 0x8a, 0xd4, 0x95, 0xcb, 0x29, 0x77, 0xf4, 0xaa, 0x48, 0x16,
+    0xe9, 0xb7, 0x55, 0x0b, 0x88, 0xd6, 0x34, 0x6a, 0x2b, 0x75, 0x97, 0xc9, 0x4a, 0x14, 0xf6, 0xa8,
+    0x74, 0x2a, 0xc8, 0x96, 0x15, 0x4b, 0xa9, 0xf7, 0xb6, 0xe8, 0x0a, 0x54, 0xd7, 0x89, 0x6b, 0x35,
+]);
+function crc8(data, len) {
+    let crc = CRC8_INIT;
+    for (let i = 0; i < len; i++) {
+        crc = CRC8_TABLE[crc ^ data[i]];
+    }
+    return crc;
+}
+
+function logProtocolV2Debug(options, stage, details) {
+    var _a, _b, _c;
+    (_b = (_a = options === null || options === void 0 ? void 0 : options.logger) === null || _a === void 0 ? void 0 : _a.debug) === null || _b === void 0 ? void 0 : _b.call(_a, `[${(_c = options.logPrefix) !== null && _c !== void 0 ? _c : 'ProtocolV2'}] ${stage}`, Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (options.context ? { context: options.context } : {})), (options.messageName ? { messageName: options.messageName } : {})), (options.messageTypeId !== undefined ? { messageTypeId: options.messageTypeId } : {})), (options.pbPayloadLength !== undefined ? { pbPayloadLength: options.pbPayloadLength } : {})), details));
+}
+
+const PROTO_SEQ_DEFAULT = 1;
+function nextProtoSeq(current) {
+    return current >= 255 ? 1 : current + 1;
+}
+function encodeFrame(payload, packetSrc, router, debugOptions, seq) {
+    const resolvedPacketSrc = packetSrc !== null && packetSrc !== void 0 ? packetSrc : 0;
+    const resolvedRouter = router !== null && router !== void 0 ? router : 0;
+    const resolvedSeq = seq !== null && seq !== void 0 ? seq : PROTO_SEQ_DEFAULT;
+    if (!Number.isInteger(resolvedSeq) || resolvedSeq < 1 || resolvedSeq > 255) {
+        throw new Error(`Protocol V2 seq out of range (1-255): ${resolvedSeq}`);
+    }
+    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}`);
+    }
+    const frame = new Uint8Array(frameLen);
+    frame[0] = PROTO_HEAD_SOF;
+    frame[1] = frameLen % 256;
+    frame[2] = Math.floor(frameLen / 256) % 256;
+    frame[3] = 0;
+    frame[4] = resolvedRouter % 256;
+    frame[5] = (resolvedPacketSrc % 16) * 4 + (PROTO_DATA_TYPE_PACKET % 4);
+    frame[6] = resolvedSeq;
+    frame[3] = crc8(frame, 3);
+    if (payload && payloadLen > 0) {
+        frame.set(payload, 7);
+    }
+    frame[frameLen - 1] = crc8(frame, frameLen - 1);
+    logProtocolV2Debug(debugOptions, 'encode raw frame', {
+        frameLen,
+        payloadLen,
+        packetSrc: resolvedPacketSrc,
+        router: frame[4],
+        attr: frame[5],
+        seq: frame[6],
+        headerCrc: frame[3],
+        frameCrc: frame[frameLen - 1],
+    });
+    return frame;
+}
+function encodeProtobufFrame(messageTypeId, pbPayload, packetSrc, router, debugOptions, seq) {
+    const payload = new Uint8Array(2 + pbPayload.length);
+    payload[0] = messageTypeId % 256;
+    payload[1] = Math.floor(messageTypeId / 256) % 256;
+    payload.set(pbPayload, 2);
+    return encodeFrame(payload, packetSrc, router, Object.assign(Object.assign({}, debugOptions), { messageTypeId, pbPayloadLength: pbPayload.length }), seq);
+}
+
+function decodeFrame(data, debugOptions) {
+    if (data.length < PROTO_HEAD_CRC_SIZE) {
+        throw new Error(`Protocol V2 frame too short: ${data.length} bytes`);
+    }
+    if (data[0] !== PROTO_HEAD_SOF) {
+        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}`);
+    }
+    const expectedHeaderCrc = crc8(data, 3);
+    if (data[3] !== expectedHeaderCrc) {
+        throw new Error(`Header CRC mismatch: expected 0x${expectedHeaderCrc
+            .toString(16)
+            .padStart(2, '0')}, got 0x${data[3].toString(16).padStart(2, '0')}`);
+    }
+    const expectedFrameCrc = crc8(data, frameLen - 1);
+    if (data[frameLen - 1] !== expectedFrameCrc) {
+        throw new Error(`Frame CRC mismatch: expected 0x${expectedFrameCrc
+            .toString(16)
+            .padStart(2, '0')}, got 0x${data[frameLen - 1].toString(16).padStart(2, '0')}`);
+    }
+    const seq = data[6];
+    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);
+    logProtocolV2Debug(debugOptions, 'decode raw frame', {
+        frameLen,
+        dataLength: data.length,
+        router: data[4],
+        attr: data[5],
+        seq,
+        headerCrc: data[3],
+        expectedHeaderCrc,
+        frameCrc: data[frameLen - 1],
+        expectedFrameCrc,
+        messageTypeId,
+        pbPayloadLength: pbPayload.length,
+    });
+    return { messageTypeId, pbPayload, seq };
+}
+
+function concatUint8Arrays(arrays) {
+    const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const arr of arrays) {
+        result.set(arr, offset);
+        offset += arr.length;
+    }
+    return result;
+}
+class ProtocolV2FrameAssembler {
+    constructor(maxFrameBytes = PROTOCOL_V2_FRAME_MAX_BYTES) {
+        this.buffer = new Uint8Array(0);
+        this.maxFrameBytes = maxFrameBytes;
+    }
+    reset() {
+        this.buffer = new Uint8Array(0);
+    }
+    push(chunk) {
+        this.append(chunk);
+        return this.extractFrame();
+    }
+    drain(chunk = new Uint8Array(0)) {
+        this.append(chunk);
+        const frames = [];
+        for (;;) {
+            const frame = this.extractFrame();
+            if (!frame)
+                break;
+            frames.push(frame);
+        }
+        return frames;
+    }
+    append(chunk) {
+        if (chunk.length > 0) {
+            this.buffer = concatUint8Arrays([this.buffer, chunk]);
+        }
+    }
+    extractFrame() {
+        if (this.buffer.length < 3)
+            return undefined;
+        if (this.buffer[0] !== PROTO_HEAD_SOF) {
+            this.reset();
+            throw new Error('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}`);
+        }
+        if (expectedLen > this.maxFrameBytes) {
+            this.reset();
+            throw new Error(`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
+                .toString(16)
+                .padStart(2, '0')}`);
+        }
+        if (this.buffer.length < expectedLen)
+            return undefined;
+        const frame = this.buffer.slice(0, expectedLen);
+        this.buffer = this.buffer.slice(expectedLen);
+        return frame;
+    }
+}
+
+var protocolV2Codec = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    PROTO_HEAD_SOF: PROTO_HEAD_SOF,
+    PROTO_PRE_HEAD_SIZE: PROTO_PRE_HEAD_SIZE,
+    PROTO_HEAD_CRC_SIZE: PROTO_HEAD_CRC_SIZE,
+    CRC8_INIT: CRC8_INIT,
+    PACKET_SIZE: PACKET_SIZE,
+    PROTO_DATA_TYPE_PACKET: PROTO_DATA_TYPE_PACKET,
+    CRC8_TABLE: CRC8_TABLE,
+    crc8: crc8,
+    logProtocolV2Debug: logProtocolV2Debug,
+    nextProtoSeq: nextProtoSeq,
+    encodeFrame: encodeFrame,
+    encodeProtobufFrame: encodeProtobufFrame,
+    decodeFrame: decodeFrame,
+    concatUint8Arrays: concatUint8Arrays,
+    ProtocolV2FrameAssembler: ProtocolV2FrameAssembler
+});
+
+const PROTOCOL_V2_SYS_MESSAGE_THRESHOLD = 60000;
+const resolveProtocolV2EncodeSchema = (name, schemas) => {
+    try {
+        schemas.protocolV2.lookupType(name);
+        return schemas.protocolV2;
+    }
+    catch (_a) {
+        throw new Error(`Protocol V2 message "${name}" is not defined in Protocol V2 schema`);
+    }
+};
+const PROTOCOL_V2_LEGACY_DECODE_ALLOWLIST = new Set([
+    'ButtonRequest',
+    'EntropyRequest',
+    'PinMatrixRequest',
+    'PassphraseRequest',
+    'Deprecated_PassphraseStateRequest',
+    'WordRequest',
+]);
+const createProtocolV2MessageFromType = (messageTypeId, schemas) => {
+    try {
+        return createMessageFromType(schemas.protocolV2, messageTypeId);
+    }
+    catch (protocolV2Error) {
+        let legacyMessage;
+        try {
+            legacyMessage = createMessageFromType(schemas.protocolV1, messageTypeId);
+        }
+        catch (_a) {
+            throw protocolV2Error;
+        }
+        if (PROTOCOL_V2_LEGACY_DECODE_ALLOWLIST.has(legacyMessage.messageName)) {
+            return legacyMessage;
+        }
+        throw protocolV2Error;
+    }
+};
+const ProtocolV1 = {
+    encodeEnvelope: encodeEnvelopeMessage,
+    encodeMessageChunks,
+    encodeTransportPackets,
+    decodeFirstChunk,
+    decodeMessage: decodeMessage,
+};
+const ProtocolV2 = {
+    encodeFrame(schemas, name, data, options = {}) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const encodeMessages = resolveProtocolV2EncodeSchema(name, schemas);
+        const { Message, messageTypeId } = createMessageFromName(encodeMessages, name);
+        const pbBuffer = encode(Message, data);
+        pbBuffer.reset();
+        const rawPbBuffer = pbBuffer.toBuffer();
+        const pbBytes = new Uint8Array(rawPbBuffer);
+        (_b = (_a = options.logger) === null || _a === void 0 ? void 0 : _a.debug) === null || _b === void 0 ? void 0 : _b.call(_a, `[${(_c = options.logPrefix) !== null && _c !== void 0 ? _c : 'ProtocolV2'}] encode protobuf`, {
+            context: (_d = options.context) !== null && _d !== void 0 ? _d : `encode:${name}`,
+            messageName: name,
+            messageTypeId,
+            pbPayloadLength: pbBytes.length,
+            packetSrc: (_e = options.packetSrc) !== null && _e !== void 0 ? _e : 0,
+            router: (_f = options.router) !== null && _f !== void 0 ? _f : 0,
+        });
+        return encodeProtobufFrame(messageTypeId, pbBytes, options.packetSrc, options.router, {
+            logger: options.logger,
+            logPrefix: options.logPrefix,
+            context: (_g = options.context) !== null && _g !== void 0 ? _g : `encode:${name}`,
+            messageName: name,
+        }, options.seq);
+    },
+    decodeFrame(schemas, frame, options = {}) {
+        var _a, _b, _c, _d, _e;
+        const { messageTypeId, pbPayload, seq } = decodeFrame(frame, {
+            logger: options.logger,
+            logPrefix: options.logPrefix,
+            context: (_a = options.context) !== null && _a !== void 0 ? _a : 'decode',
+        });
+        const { Message, messageName } = createProtocolV2MessageFromType(messageTypeId, schemas);
+        const rxByteBuffer = ByteBuffer__default["default"].wrap(Buffer.from(pbPayload));
+        const message = decode(Message, rxByteBuffer);
+        (_c = (_b = options.logger) === null || _b === void 0 ? void 0 : _b.debug) === null || _c === void 0 ? void 0 : _c.call(_b, `[${(_d = options.logPrefix) !== null && _d !== void 0 ? _d : 'ProtocolV2'}] decode protobuf`, {
+            context: (_e = options.context) !== null && _e !== void 0 ? _e : `decode:${messageName}`,
+            messageName,
+            messageTypeId,
+            pbPayloadLength: pbPayload.length,
+            seq,
+        });
+        return {
+            message,
+            messageName,
+            messageTypeId,
+            pbPayload,
+            seq,
+            type: messageName,
+        };
+    },
+};
+
+var index$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    decodeEnvelope: decodeEnvelope,
+    decodeFirstChunk: decodeFirstChunk,
+    encodeEnvelope: encodeEnvelope,
+    encodeEnvelopeMessage: encodeEnvelopeMessage,
+    encodeMessageChunks: encodeMessageChunks,
+    encodeTransportPackets: encodeTransportPackets,
+    decodeMessage: decodeMessage
+});
+
 const ERROR = 'Wrong result type.';
 function info(res) {
     if (typeof res !== 'object' || res == null) {
@@ -435,6 +787,271 @@ var check = /*#__PURE__*/Object.freeze({
     call: call
 });
 
+const LogBlockCommand = new Set([
+    'PassphraseAck',
+    'PinMatrixAck',
+    'FilesystemFileWrite',
+    'FileWrite',
+    'EmmcFileWrite',
+    'FirmwareUpload',
+    'ResourceAck',
+]);
+
+function hexToBytes(hex) {
+    const clean = hex.replace(/\s+/g, '');
+    if (clean.length % 2 !== 0) {
+        throw new Error(`Invalid hex string: odd length ${clean.length}`);
+    }
+    if (!/^[0-9a-fA-F]*$/.test(clean)) {
+        throw new Error('Invalid hex string: contains non-hex characters');
+    }
+    const bytes = new Uint8Array(clean.length / 2);
+    for (let i = 0; i < bytes.length; i += 1) {
+        bytes[i] = parseInt(clean.substring(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+}
+function bytesToHex(bytes) {
+    return Array.from(bytes)
+        .map(b => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+const PROTOCOL_V2_DEBUG_HEADER_BYTES = 7;
+const PROTOCOL_V2_DEBUG_ARRAY_ITEMS_LIMIT = 20;
+const PROTOCOL_V2_DEBUG_OBJECT_KEYS_LIMIT = 40;
+const PROTOCOL_V2_DEBUG_STRING_LIMIT = 512;
+const PROTOCOL_V2_DEBUG_DEPTH_LIMIT = 4;
+const HIGH_VOLUME_PROTOCOL_V2_CALLS = new Set([
+    ...LogBlockCommand,
+    'FilesystemFileRead',
+    'FileRead',
+    'EmmcFileRead',
+]);
+function shouldReduceProtocolV2Debug(name) {
+    return HIGH_VOLUME_PROTOCOL_V2_CALLS.has(name);
+}
+function frameHeaderDebugHex(frame) {
+    return bytesToHex(frame.slice(0, PROTOCOL_V2_DEBUG_HEADER_BYTES));
+}
+function getBinaryByteLength(value) {
+    if (value instanceof ArrayBuffer) {
+        return value.byteLength;
+    }
+    if (ArrayBuffer.isView(value)) {
+        return value.byteLength;
+    }
+    if (typeof Blob !== 'undefined' && value instanceof Blob) {
+        return value.size;
+    }
+    return undefined;
+}
+function summarizeRedactedData(value) {
+    const byteLength = getBinaryByteLength(value);
+    if (byteLength !== undefined) {
+        return `[redacted data: ${byteLength} bytes]`;
+    }
+    if (typeof value === 'string') {
+        return `[redacted data: string length=${value.length}]`;
+    }
+    if (Array.isArray(value)) {
+        return `[redacted data: array length=${value.length}]`;
+    }
+    if (value && typeof value === 'object') {
+        return `[redacted data: object keys=${Object.keys(value).length}]`;
+    }
+    return `[redacted data: ${typeof value}]`;
+}
+function sanitizeProtocolV2DebugPayload(value, key = '', depth = 0) {
+    if (/^(data|payload)$/i.test(key) && value !== null && value !== undefined) {
+        return summarizeRedactedData(value);
+    }
+    if (/(passphrase|pin|mnemonic|seed|private)/i.test(key)) {
+        return '[redacted sensitive value]';
+    }
+    const byteLength = getBinaryByteLength(value);
+    if (byteLength !== undefined) {
+        return `[binary: ${byteLength} bytes]`;
+    }
+    if (typeof value === 'string') {
+        return value.length > PROTOCOL_V2_DEBUG_STRING_LIMIT
+            ? `${value.slice(0, PROTOCOL_V2_DEBUG_STRING_LIMIT)}... (len=${value.length})`
+            : value;
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    if (depth >= PROTOCOL_V2_DEBUG_DEPTH_LIMIT) {
+        return Array.isArray(value)
+            ? `[array length=${value.length}]`
+            : `[object keys=${Object.keys(value).length}]`;
+    }
+    if (Array.isArray(value)) {
+        const items = value
+            .slice(0, PROTOCOL_V2_DEBUG_ARRAY_ITEMS_LIMIT)
+            .map(item => sanitizeProtocolV2DebugPayload(item, key, depth + 1));
+        if (value.length > PROTOCOL_V2_DEBUG_ARRAY_ITEMS_LIMIT) {
+            items.push(`... (${value.length - PROTOCOL_V2_DEBUG_ARRAY_ITEMS_LIMIT} more)`);
+        }
+        return items;
+    }
+    const entries = Object.entries(value).slice(0, PROTOCOL_V2_DEBUG_OBJECT_KEYS_LIMIT);
+    const sanitized = {};
+    entries.forEach(([entryKey, entryValue]) => {
+        sanitized[entryKey] = sanitizeProtocolV2DebugPayload(entryValue, entryKey, depth + 1);
+    });
+    if (Object.keys(value).length > PROTOCOL_V2_DEBUG_OBJECT_KEYS_LIMIT) {
+        sanitized.__truncated__ = `${Object.keys(value).length - PROTOCOL_V2_DEBUG_OBJECT_KEYS_LIMIT} more keys`;
+    }
+    return sanitized;
+}
+const COMMON_TERMINAL_RESPONSE_TYPES = new Set([
+    'Failure',
+    'ButtonRequest',
+    'EntropyRequest',
+    'PinMatrixRequest',
+    'PassphraseRequest',
+    'Deprecated_PassphraseStateRequest',
+    'WordRequest',
+]);
+function isExpectedTerminalResponse(response, expectedTypes) {
+    if (!expectedTypes || expectedTypes.length === 0)
+        return true;
+    return expectedTypes.includes(response.type) || COMMON_TERMINAL_RESPONSE_TYPES.has(response.type);
+}
+function getErrorMessage(error) {
+    if (!error)
+        return '';
+    if (typeof error === 'string')
+        return error;
+    if (typeof error === 'object' && 'message' in error) {
+        const { message } = error;
+        return typeof message === 'string' ? message : String(message !== null && message !== void 0 ? message : '');
+    }
+    return String(error);
+}
+function withProtocolTimeout(promise, timeoutMs, createTimeoutError, onTimeout) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!timeoutMs)
+            return promise;
+        let timer;
+        try {
+            return yield Promise.race([
+                promise,
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => {
+                        onTimeout === null || onTimeout === void 0 ? void 0 : onTimeout();
+                        reject(createTimeoutError());
+                    }, timeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    });
+}
+const PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS = 30000;
+class ProtocolV2Session {
+    constructor(options) {
+        this.pendingCall = Promise.resolve();
+        this.protoSeq = 0;
+        this.options = options;
+    }
+    call(name, data, callOptions = {}) {
+        const run = () => this.executeCall(name, data, callOptions);
+        const result = this.pendingCall.then(run, run);
+        this.pendingCall = result.catch(() => undefined);
+        return result;
+    }
+    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 shouldReduceDebug = shouldReduceProtocolV2Debug(name);
+            this.protoSeq = nextProtoSeq(this.protoSeq);
+            const frame = ProtocolV2.encodeFrame(schemas, name, data, {
+                packetSrc,
+                router,
+                seq: this.protoSeq,
+                logger: shouldReduceDebug ? undefined : logger,
+                logPrefix,
+                context: `tx:${name}`,
+            });
+            const expectedSeq = frame[6];
+            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}`));
+            const cancellation = { cancelled: false };
+            const readResponse = () => __awaiter(this, void 0, void 0, function* () {
+                var _c, _d, _e, _f, _g, _h, _j, _k;
+                while (!cancellation.cancelled) {
+                    const rxFrame = yield readFrame();
+                    if (cancellation.cancelled) {
+                        break;
+                    }
+                    if (!shouldReduceDebug) {
+                        (_c = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _c === void 0 ? void 0 : _c.call(logger, `[${logPrefix}] RX frame len=${rxFrame.length} router=${rxFrame[4]} attr=${rxFrame[5]} seq=${rxFrame[6]} headerHex=${frameHeaderDebugHex(rxFrame)}`);
+                    }
+                    const decoded = ProtocolV2.decodeFrame(schemas, rxFrame, {
+                        logger: shouldReduceDebug ? undefined : logger,
+                        logPrefix,
+                        context: `rx:${name}`,
+                    });
+                    if (!shouldReduceDebug && decoded.seq !== expectedSeq) {
+                        (_d = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _d === void 0 ? void 0 : _d.call(logger, `[${logPrefix}] seq differs for ${name}: tx=${expectedSeq}, rx=${decoded.seq}`);
+                    }
+                    if (!shouldReduceDebug) {
+                        (_e = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _e === void 0 ? void 0 : _e.call(logger, `[${logPrefix}] TX name=${name} seq=${expectedSeq} | RX seq=${decoded.seq} messageTypeId=${decoded.messageTypeId} pbPayload=${decoded.pbPayload.length}B`);
+                        (_f = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _f === void 0 ? void 0 : _f.call(logger, `[${logPrefix}] RX payload type=${decoded.type} messageTypeId=${decoded.messageTypeId}`, sanitizeProtocolV2DebugPayload(decoded.message));
+                    }
+                    const response = call(decoded);
+                    if ((_g = callOptions.intermediateTypes) === null || _g === void 0 ? void 0 : _g.includes(response.type)) {
+                        (_h = callOptions.onIntermediateResponse) === null || _h === void 0 ? void 0 : _h.call(callOptions, response);
+                    }
+                    else if (isExpectedTerminalResponse(response, callOptions.expectedTypes)) {
+                        return response;
+                    }
+                    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}`);
+                    }
+                }
+                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;
+            });
+        });
+    }
+}
+function probeProtocolV2({ call, timeoutMs, logger, logPrefix = 'ProtocolV2', onBeforeProbe, onProbeFailed, }) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        let pingError;
+        try {
+            yield (onBeforeProbe === null || onBeforeProbe === void 0 ? void 0 : onBeforeProbe());
+            const response = yield call('Ping', { message: 'probe' }, { timeoutMs, expectedTypes: ['Success'] });
+            if (response.type === 'Success') {
+                return true;
+            }
+            pingError = new Error(`unexpected response type ${response.type}`);
+        }
+        catch (error) {
+            pingError = error;
+        }
+        (_a = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _a === void 0 ? void 0 : _a.call(logger, `[${logPrefix}] Protocol V2 ping probe failed:`, getErrorMessage(pingError));
+        yield (onProbeFailed === null || onProbeFailed === void 0 ? void 0 : onProbeFailed(pingError));
+        return false;
+    });
+}
+
 exports.AptosTransactionType = void 0;
 (function (AptosTransactionType) {
     AptosTransactionType[AptosTransactionType["STANDARD"] = 0] = "STANDARD";
@@ -500,6 +1117,7 @@ exports.Enum_RequestType = void 0;
     Enum_RequestType[Enum_RequestType["TXEXTRADATA"] = 4] = "TXEXTRADATA";
     Enum_RequestType[Enum_RequestType["TXORIGINPUT"] = 5] = "TXORIGINPUT";
     Enum_RequestType[Enum_RequestType["TXORIGOUTPUT"] = 6] = "TXORIGOUTPUT";
+    Enum_RequestType[Enum_RequestType["TXPAYMENTREQ"] = 7] = "TXPAYMENTREQ";
 })(exports.Enum_RequestType || (exports.Enum_RequestType = {}));
 exports.RebootType = void 0;
 (function (RebootType) {
@@ -682,6 +1300,9 @@ exports.Enum_BackupType = void 0;
     Enum_BackupType[Enum_BackupType["Bip39"] = 0] = "Bip39";
     Enum_BackupType[Enum_BackupType["Slip39_Basic"] = 1] = "Slip39_Basic";
     Enum_BackupType[Enum_BackupType["Slip39_Advanced"] = 2] = "Slip39_Advanced";
+    Enum_BackupType[Enum_BackupType["Slip39_Single_Extendable"] = 3] = "Slip39_Single_Extendable";
+    Enum_BackupType[Enum_BackupType["Slip39_Basic_Extendable"] = 4] = "Slip39_Basic_Extendable";
+    Enum_BackupType[Enum_BackupType["Slip39_Advanced_Extendable"] = 5] = "Slip39_Advanced_Extendable";
 })(exports.Enum_BackupType || (exports.Enum_BackupType = {}));
 exports.Enum_SafetyCheckLevel = void 0;
 (function (Enum_SafetyCheckLevel) {
@@ -867,6 +1488,86 @@ exports.CommandFlags = void 0;
     CommandFlags[CommandFlags["Default"] = 0] = "Default";
     CommandFlags[CommandFlags["Factory_Only"] = 1] = "Factory_Only";
 })(exports.CommandFlags || (exports.CommandFlags = {}));
+exports.MoneroNetworkType = void 0;
+(function (MoneroNetworkType) {
+    MoneroNetworkType[MoneroNetworkType["MAINNET"] = 0] = "MAINNET";
+    MoneroNetworkType[MoneroNetworkType["TESTNET"] = 1] = "TESTNET";
+    MoneroNetworkType[MoneroNetworkType["STAGENET"] = 2] = "STAGENET";
+    MoneroNetworkType[MoneroNetworkType["FAKECHAIN"] = 3] = "FAKECHAIN";
+})(exports.MoneroNetworkType || (exports.MoneroNetworkType = {}));
+exports.TxDetailsDisplayType = void 0;
+(function (TxDetailsDisplayType) {
+    TxDetailsDisplayType[TxDetailsDisplayType["DISPLAY_TYPE_INFO"] = 0] = "DISPLAY_TYPE_INFO";
+    TxDetailsDisplayType[TxDetailsDisplayType["DISPLAY_TYPE_SIGN"] = 1] = "DISPLAY_TYPE_SIGN";
+})(exports.TxDetailsDisplayType || (exports.TxDetailsDisplayType = {}));
+exports.DevRebootType = void 0;
+(function (DevRebootType) {
+    DevRebootType[DevRebootType["Normal"] = 0] = "Normal";
+    DevRebootType[DevRebootType["Boardloader"] = 1] = "Boardloader";
+    DevRebootType[DevRebootType["Bootloader"] = 2] = "Bootloader";
+})(exports.DevRebootType || (exports.DevRebootType = {}));
+exports.DeviceRebootType = void 0;
+(function (DeviceRebootType) {
+    DeviceRebootType[DeviceRebootType["Normal"] = 0] = "Normal";
+    DeviceRebootType[DeviceRebootType["Romloader"] = 1] = "Romloader";
+    DeviceRebootType[DeviceRebootType["Bootloader"] = 2] = "Bootloader";
+})(exports.DeviceRebootType || (exports.DeviceRebootType = {}));
+exports.DeviceType = void 0;
+(function (DeviceType) {
+    DeviceType[DeviceType["CLASSIC1"] = 0] = "CLASSIC1";
+    DeviceType[DeviceType["CLASSIC1S"] = 1] = "CLASSIC1S";
+    DeviceType[DeviceType["MINI"] = 2] = "MINI";
+    DeviceType[DeviceType["TOUCH"] = 3] = "TOUCH";
+    DeviceType[DeviceType["PRO"] = 5] = "PRO";
+    DeviceType[DeviceType["CLASSIC1S_PURE"] = 6] = "CLASSIC1S_PURE";
+})(exports.DeviceType || (exports.DeviceType = {}));
+exports.DevSeType = void 0;
+(function (DevSeType) {
+    DevSeType[DevSeType["THD89"] = 0] = "THD89";
+    DevSeType[DevSeType["SE608A"] = 1] = "SE608A";
+})(exports.DevSeType || (exports.DevSeType = {}));
+exports.DevSEState = void 0;
+(function (DevSEState) {
+    DevSEState[DevSEState["BOOT"] = 0] = "BOOT";
+    DevSEState[DevSEState["APP_FACTORY"] = 51] = "APP_FACTORY";
+    DevSEState[DevSEState["APP"] = 85] = "APP";
+})(exports.DevSEState || (exports.DevSEState = {}));
+exports.DevFirmwareTargetType = void 0;
+(function (DevFirmwareTargetType) {
+    DevFirmwareTargetType[DevFirmwareTargetType["TARGET_INVALID"] = 0] = "TARGET_INVALID";
+    DevFirmwareTargetType[DevFirmwareTargetType["TARGET_ROMLOADER"] = 1] = "TARGET_ROMLOADER";
+    DevFirmwareTargetType[DevFirmwareTargetType["TARGET_BOOTLOADER"] = 2] = "TARGET_BOOTLOADER";
+    DevFirmwareTargetType[DevFirmwareTargetType["TARGET_APPLICATION_P1"] = 3] = "TARGET_APPLICATION_P1";
+    DevFirmwareTargetType[DevFirmwareTargetType["TARGET_APPLICATION_P2"] = 4] = "TARGET_APPLICATION_P2";
+    DevFirmwareTargetType[DevFirmwareTargetType["TARGET_COPROCESSOR"] = 5] = "TARGET_COPROCESSOR";
+    DevFirmwareTargetType[DevFirmwareTargetType["TARGET_SE01"] = 6] = "TARGET_SE01";
+    DevFirmwareTargetType[DevFirmwareTargetType["TARGET_SE02"] = 7] = "TARGET_SE02";
+    DevFirmwareTargetType[DevFirmwareTargetType["TARGET_SE03"] = 8] = "TARGET_SE03";
+    DevFirmwareTargetType[DevFirmwareTargetType["TARGET_SE04"] = 9] = "TARGET_SE04";
+    DevFirmwareTargetType[DevFirmwareTargetType["TARGET_RESOURCE"] = 10] = "TARGET_RESOURCE";
+})(exports.DevFirmwareTargetType || (exports.DevFirmwareTargetType = {}));
+exports.DeviceFirmwareTargetType = void 0;
+(function (DeviceFirmwareTargetType) {
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["TARGET_INVALID"] = 0] = "TARGET_INVALID";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["TARGET_ROMLOADER"] = 1] = "TARGET_ROMLOADER";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["TARGET_BOOTLOADER"] = 2] = "TARGET_BOOTLOADER";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["TARGET_APPLICATION_P1"] = 3] = "TARGET_APPLICATION_P1";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["TARGET_APPLICATION_P2"] = 4] = "TARGET_APPLICATION_P2";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["TARGET_COPROCESSOR"] = 5] = "TARGET_COPROCESSOR";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["TARGET_SE01"] = 6] = "TARGET_SE01";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["TARGET_SE02"] = 7] = "TARGET_SE02";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["TARGET_SE03"] = 8] = "TARGET_SE03";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["TARGET_SE04"] = 9] = "TARGET_SE04";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["TARGET_RESOURCE"] = 10] = "TARGET_RESOURCE";
+})(exports.DeviceFirmwareTargetType || (exports.DeviceFirmwareTargetType = {}));
+exports.OnboardingStep = void 0;
+(function (OnboardingStep) {
+    OnboardingStep[OnboardingStep["ONBOARDING_STEP_UNKNOWN"] = 0] = "ONBOARDING_STEP_UNKNOWN";
+    OnboardingStep[OnboardingStep["ONBOARDING_STEP_DEVICE_VERIFICATION"] = 1] = "ONBOARDING_STEP_DEVICE_VERIFICATION";
+    OnboardingStep[OnboardingStep["ONBOARDING_STEP_PERSONALIZATION"] = 2] = "ONBOARDING_STEP_PERSONALIZATION";
+    OnboardingStep[OnboardingStep["ONBOARDING_STEP_SETUP"] = 3] = "ONBOARDING_STEP_SETUP";
+    OnboardingStep[OnboardingStep["ONBOARDING_STEP_FIRMWARE"] = 4] = "ONBOARDING_STEP_FIRMWARE";
+})(exports.OnboardingStep || (exports.OnboardingStep = {}));
 
 var messages = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -929,28 +1630,70 @@ var messages = /*#__PURE__*/Object.freeze({
     get TonSignDataType () { return exports.TonSignDataType; },
     get TronResourceCode () { return exports.TronResourceCode; },
     get TronMessageType () { return exports.TronMessageType; },
-    get CommandFlags () { return exports.CommandFlags; }
+    get CommandFlags () { return exports.CommandFlags; },
+    get MoneroNetworkType () { return exports.MoneroNetworkType; },
+    get TxDetailsDisplayType () { return exports.TxDetailsDisplayType; },
+    get DevRebootType () { return exports.DevRebootType; },
+    get DeviceRebootType () { return exports.DeviceRebootType; },
+    get DeviceType () { return exports.DeviceType; },
+    get DevSeType () { return exports.DevSeType; },
+    get DevSEState () { return exports.DevSEState; },
+    get DevFirmwareTargetType () { return exports.DevFirmwareTargetType; },
+    get DeviceFirmwareTargetType () { return exports.DeviceFirmwareTargetType; },
+    get OnboardingStep () { return exports.OnboardingStep; }
 });
 
-const LogBlockCommand = new Set(['PassphraseAck', 'PinMatrixAck']);
-
-protobuf__namespace.util.Long = Long__namespace;
+protobuf__namespace.util.Long = Long__default["default"];
 protobuf__namespace.configure();
 var index = {
     check,
-    buildOne,
-    buildBuffers,
-    buildEncodeBuffers,
-    receiveOne,
     parseConfigure,
-    decodeProtocol,
+    protocolV2: protocolV2Codec,
+    ProtocolV1,
+    ProtocolV2,
+    PROTOCOL_V2_SYS_MESSAGE_THRESHOLD,
+    ProtocolV2FrameAssembler,
+    ProtocolV2Session,
+    bytesToHex,
+    concatUint8Arrays,
+    createMessageFromName,
+    createMessageFromType,
+    encodeProtobuf: encode,
+    decodeProtobuf: decode,
+    getErrorMessage,
+    hexToBytes,
+    probeProtocolV2,
+    withProtocolTimeout,
 };
 
-exports.BUFFER_SIZE = BUFFER_SIZE;
-exports.COMMON_HEADER_SIZE = COMMON_HEADER_SIZE;
-exports.HEADER_SIZE = HEADER_SIZE;
 exports.LogBlockCommand = LogBlockCommand;
-exports.MESSAGE_HEADER_BYTE = MESSAGE_HEADER_BYTE;
-exports.MESSAGE_TOP_CHAR = MESSAGE_TOP_CHAR;
 exports.Messages = messages;
+exports.PROTOCOL_V1_CHUNK_PAYLOAD_SIZE = PROTOCOL_V1_CHUNK_PAYLOAD_SIZE;
+exports.PROTOCOL_V1_ENVELOPE_HEADER_SIZE = PROTOCOL_V1_ENVELOPE_HEADER_SIZE;
+exports.PROTOCOL_V1_HEADER_BYTE = PROTOCOL_V1_HEADER_BYTE;
+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_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_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.ProtocolV2Session = ProtocolV2Session;
+exports.bytesToHex = bytesToHex;
+exports.concatUint8Arrays = concatUint8Arrays;
 exports["default"] = index;
+exports.getErrorMessage = getErrorMessage;
+exports.hexToBytes = hexToBytes;
+exports.probeProtocolV2 = probeProtocolV2;
+exports.protocolV1 = index$1;
+exports.protocolV2 = protocolV2Codec;
+exports.withProtocolTimeout = withProtocolTimeout;