@onekeyfe/hd-transport 1.1.34-alpha.2 → 1.1.34-alpha.3

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,18 +235,25 @@ 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) => {
     const MessageType = messages.lookupEnum('MessageType');
-    const messageName = MessageType.valuesById[typeId].replace('MessageType_', '');
+    const rawMessageName = MessageType.valuesById[typeId];
+    if (!rawMessageName) {
+        throw new Error(`MessageType id "${typeId}" is not defined in protobuf schema`);
+    }
+    const messageName = rawMessageName.replace('MessageType_', '');
     const Message = messages.lookupType(messageName);
     return {
         Message,
@@ -238,55 +261,33 @@ 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 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
-});
+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 = 4000;
+const PROTOCOL_V2_BLE_FILE_CHUNK_SIZE = 1800;
+const PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE = 900;
+const PROTOCOL_V2_BLE_FRAME_MAX_BYTES = 2048;
+const PROTOCOL_V2_FILE_CHUNK_SIZE = PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+const PROTOCOL_V2_CHANNEL_USB = 0;
+const PROTOCOL_V2_CHANNEL_BLE_UART = 1;
+const PROTOCOL_V2_CHANNEL_SOCKET = 2;
+const PROTOCOL_V2_PACKET_SRC_COMMAND = 0;
 
-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 +295,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 +307,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 +338,359 @@ 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 PROTO_DATA_TYPE_ACK = 1;
+
+const CRC8_TABLE = new Uint8Array([
+    0x00, 0x5e, 0xbc, 0xe2, 0x61, 0x3f, 0xdd, 0x83, 0xc2, 0x9c, 0x7e, 0x20, 0xa3, 0xfd, 0x1f, 0x41,
+    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;
+}
+
+const PROTO_SEQ_DEFAULT = 1;
+function nextProtoSeq(current) {
+    return current >= 255 ? 1 : current + 1;
+}
+function encodeFrame(payload, packetSrc, router, 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);
+    return frame;
+}
+function encodeProtobufFrame(messageTypeId, pbPayload, packetSrc, router, 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, seq);
+}
+
+function validateFrame(data) {
+    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')}`);
+    }
+    return frameLen;
+}
+function isAckFrame(data) {
+    if (data.length < 6 || (data[5] & 0x03) !== PROTO_DATA_TYPE_ACK) {
+        return false;
+    }
+    const frameLen = validateFrame(data);
+    if (frameLen !== PROTO_HEAD_CRC_SIZE) {
+        throw new Error(`Invalid Protocol V2 ACK frame length: ${frameLen}`);
+    }
+    return true;
+}
+function decodeFrame(data) {
+    const frameLen = validateFrame(data);
+    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);
+    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,
+    PROTO_DATA_TYPE_ACK: PROTO_DATA_TYPE_ACK,
+    CRC8_TABLE: CRC8_TABLE,
+    crc8: crc8,
+    nextProtoSeq: nextProtoSeq,
+    encodeFrame: encodeFrame,
+    encodeProtobufFrame: encodeProtobufFrame,
+    isAckFrame: isAckFrame,
+    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([
+    'Failure',
+    '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 = {
+    isAckFrame,
+    inspectFrame(schemas, frame) {
+        const { messageTypeId, pbPayload, seq } = decodeFrame(frame);
+        const { messageName } = createProtocolV2MessageFromType(messageTypeId, schemas);
+        return {
+            messageName,
+            messageTypeId,
+            pbPayload,
+            seq,
+            type: messageName,
+        };
+    },
+    encodeFrame(schemas, name, data, options = {}) {
+        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);
+        return encodeProtobufFrame(messageTypeId, pbBytes, options.packetSrc, options.router, options.seq);
+    },
+    decodeFrame(schemas, frame) {
+        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);
+        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
+});
+
+class ProtocolV2SequenceCursor {
+    constructor() {
+        this.current = 0;
+    }
+    next() {
+        this.current = nextProtoSeq(this.current);
+        return this.current;
+    }
+}
+
 const ERROR = 'Wrong result type.';
 function info(res) {
     if (typeof res !== 'object' || res == null) {
@@ -435,6 +778,425 @@ 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 HIGH_VOLUME_PROTOCOL_V2_CALLS = new Set([
+    ...LogBlockCommand,
+    'FilesystemFileRead',
+    'FileRead',
+    'EmmcFileRead',
+]);
+function shouldReduceProtocolV2Debug(name) {
+    return HIGH_VOLUME_PROTOCOL_V2_CALLS.has(name);
+}
+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) {
+        var _a;
+        this.pendingCall = Promise.resolve();
+        this.options = options;
+        this.sequenceCursor = (_a = options.sequenceCursor) !== null && _a !== void 0 ? _a : new ProtocolV2SequenceCursor();
+    }
+    call(name, data, callOptions = {}) {
+        const run = () => this.executeCall(name, data, callOptions);
+        const result = this.pendingCall.then(run, run);
+        this.pendingCall = result.catch(() => undefined);
+        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, writeTimeoutMs = PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS, } = 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 protoSeq = this.sequenceCursor.next();
+            const frame = ProtocolV2.encodeFrame(schemas, name, data, {
+                packetSrc,
+                router,
+                seq: protoSeq,
+            });
+            if (maxFrameBytes !== undefined && frame.length > maxFrameBytes) {
+                throw new Error(`Protocol V2 frame too large for transport: ${frame.length} > ${maxFrameBytes}`);
+            }
+            yield withProtocolTimeout(writeFrame(frame, callContext), writeTimeoutMs, () => new Error(`Protocol V2 write timeout after ${writeTimeoutMs}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 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}`);
+                        }
+                    }
+                }
+                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 probeError;
+        try {
+            yield (onBeforeProbe === null || onBeforeProbe === void 0 ? void 0 : onBeforeProbe());
+            const response = yield call('Ping', { message: 'protocol-v2-probe' }, { timeoutMs, expectedTypes: ['Success'] });
+            if (response.type === 'Success') {
+                return true;
+            }
+            probeError = new Error(`unexpected response type ${response.type}`);
+        }
+        catch (error) {
+            probeError = error;
+        }
+        (_a = logger === null || logger === void 0 ? void 0 : logger.debug) === null || _a === void 0 ? void 0 : _a.call(logger, `[${logPrefix}] Protocol V2 probe failed:`, getErrorMessage(probeError));
+        yield (onProbeFailed === null || onProbeFailed === void 0 ? void 0 : onProbeFailed(probeError));
+        return false;
+    });
+}
+
+class ProtocolV2LinkManager {
+    constructor(options) {
+        this.links = new Map();
+        this.sequences = new Map();
+        this.callQueues = new Map();
+        this.options = options;
+    }
+    call(key, createAdapter, name, data, options) {
+        var _a;
+        const run = () => this.executeCall(key, createAdapter, name, data, options);
+        const previous = (_a = this.callQueues.get(key)) !== null && _a !== void 0 ? _a : Promise.resolve();
+        const result = previous.then(run, run);
+        const queue = result.catch(() => undefined);
+        this.callQueues.set(key, queue);
+        result
+            .then(() => this.clearSettledCallQueue(key, queue), () => this.clearSettledCallQueue(key, queue))
+            .catch(() => undefined);
+        return result;
+    }
+    invalidateLink(key, reason) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const link = this.links.get(key);
+            if (!link)
+                return;
+            this.links.delete(key);
+            link.state.invalidatedReason = reason;
+            yield link.adapter.reset(reason);
+            yield ((_b = (_a = this.options).onLinkInvalidated) === null || _b === void 0 ? void 0 : _b.call(_a, key, reason));
+        });
+    }
+    invalidateAllLinks(reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(Array.from(this.links.keys(), key => this.invalidateLink(key, reason)));
+        });
+    }
+    dispose(reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.invalidateAllLinks(reason);
+            this.sequences.clear();
+            this.callQueues.clear();
+        });
+    }
+    getOrCreateLink(key, createAdapter) {
+        const existing = this.links.get(key);
+        if (existing)
+            return existing;
+        const adapter = createAdapter();
+        const state = {};
+        const assertLinkActive = () => {
+            if (state.invalidatedReason) {
+                throw new Error(state.invalidatedReason);
+            }
+        };
+        let sequenceCursor = this.sequences.get(key);
+        if (!sequenceCursor) {
+            sequenceCursor = new ProtocolV2SequenceCursor();
+            this.sequences.set(key, sequenceCursor);
+        }
+        const session = new ProtocolV2Session({
+            schemas: this.options.getSchemas(),
+            router: adapter.router,
+            maxFrameBytes: adapter.maxFrameBytes,
+            generation: adapter.generation,
+            sequenceCursor,
+            prepareCall: (context) => __awaiter(this, void 0, void 0, function* () {
+                assertLinkActive();
+                yield adapter.prepareCall(context);
+                assertLinkActive();
+            }),
+            writeFrame: (frame, context) => __awaiter(this, void 0, void 0, function* () {
+                assertLinkActive();
+                yield adapter.writeFrame(frame, context);
+                assertLinkActive();
+            }),
+            readFrame: (context) => __awaiter(this, void 0, void 0, function* () {
+                assertLinkActive();
+                const frame = yield adapter.readFrame(context);
+                assertLinkActive();
+                return frame;
+            }),
+            logger: adapter.logger,
+            logPrefix: adapter.logPrefix,
+            createTimeoutError: adapter.createTimeoutError,
+            writeTimeoutMs: adapter.writeTimeoutMs,
+        });
+        const link = { adapter, session, state };
+        this.links.set(key, link);
+        return link;
+    }
+    executeCall(key, createAdapter, name, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.getOrCreateLink(key, createAdapter).session.call(name, data, options);
+            }
+            catch (error) {
+                if (this.options.classifyError(error) === 'link-fatal') {
+                    const errorMessage = getErrorMessage(error) || 'unknown error';
+                    yield this.invalidateLink(key, `Protocol V2 link-fatal error: ${errorMessage}`);
+                }
+                throw error;
+            }
+        });
+    }
+    clearSettledCallQueue(key, queue) {
+        if (this.callQueues.get(key) === queue) {
+            this.callQueues.delete(key);
+        }
+    }
+}
+
+class ProtocolV2UsbTransportBase {
+    constructor(options) {
+        this.protocolV2UsbAssemblers = new Map();
+        this.protocolV2UsbGenerations = new Map();
+        this.protocolV2UsbCancellations = new Map();
+        this.protocolV2UsbOptions = options;
+        this.protocolV2UsbLinks = new ProtocolV2LinkManager({
+            getSchemas: () => this.getProtocolV2UsbSchemas(),
+            classifyError: () => 'link-fatal',
+            onLinkInvalidated: (key, reason) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                (_a = this.protocolV2UsbAssemblers.get(key)) === null || _a === void 0 ? void 0 : _a.reset();
+                yield this.resetProtocolV2UsbNativeLink(key, reason);
+                yield this.onProtocolV2UsbLinkInvalidated(key, reason);
+            }),
+        });
+    }
+    onProtocolV2UsbLinkInvalidated(_key, _reason) {
+    }
+    rotateProtocolV2UsbGeneration(key, reason) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.protocolV2UsbLinks.invalidateLink(key, reason);
+            const generation = ((_a = this.protocolV2UsbGenerations.get(key)) !== null && _a !== void 0 ? _a : 0) + 1;
+            this.protocolV2UsbGenerations.set(key, generation);
+            this.protocolV2UsbCancellations.set(key, this.createProtocolV2UsbCancellation(generation));
+            this.protocolV2UsbAssemblers.set(key, new ProtocolV2FrameAssembler(this.protocolV2UsbOptions.maxFrameBytes));
+            return generation;
+        });
+    }
+    callProtocolV2Usb(key, name, data, options) {
+        return this.protocolV2UsbLinks.call(key, () => this.createProtocolV2UsbAdapter(key), name, data, options);
+    }
+    invalidateProtocolV2UsbLink(key, reason) {
+        return this.protocolV2UsbLinks.invalidateLink(key, reason);
+    }
+    invalidateAllProtocolV2UsbLinks(reason) {
+        return this.protocolV2UsbLinks.invalidateAllLinks(reason);
+    }
+    disposeProtocolV2UsbLinks(reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.protocolV2UsbLinks.dispose(reason);
+            this.protocolV2UsbAssemblers.clear();
+            this.protocolV2UsbGenerations.clear();
+            this.protocolV2UsbCancellations.clear();
+        });
+    }
+    createProtocolV2UsbAdapter(key) {
+        const generation = this.protocolV2UsbGenerations.get(key);
+        if (generation === undefined) {
+            throw new Error('Protocol V2 USB generation has not been initialized');
+        }
+        const cancellation = this.protocolV2UsbCancellations.get(key);
+        if (!cancellation || cancellation.generation !== generation) {
+            throw new Error('Protocol V2 USB cancellation state has not been initialized');
+        }
+        const assertCurrentGeneration = () => {
+            if (cancellation.reason) {
+                throw new Error(cancellation.reason);
+            }
+            if (this.protocolV2UsbGenerations.get(key) !== generation) {
+                throw new Error('Protocol V2 USB connection generation changed');
+            }
+        };
+        return {
+            router: this.protocolV2UsbOptions.router,
+            maxFrameBytes: this.protocolV2UsbOptions.maxFrameBytes,
+            generation,
+            prepareCall: () => {
+                assertCurrentGeneration();
+                this.getProtocolV2UsbAssembler(key).reset();
+            },
+            writeFrame: (frame, context) => __awaiter(this, void 0, void 0, function* () {
+                assertCurrentGeneration();
+                yield this.writeProtocolV2UsbPacket(key, frame, context);
+                assertCurrentGeneration();
+            }),
+            readFrame: (context) => __awaiter(this, void 0, void 0, function* () {
+                assertCurrentGeneration();
+                const assembler = this.getProtocolV2UsbAssembler(key);
+                let frame = assembler.push(new Uint8Array(0));
+                while (!frame) {
+                    const packetRead = this.readProtocolV2UsbPacket(key, context).then(packet => ({
+                        packet,
+                    }));
+                    const cancelled = cancellation.promise.then(reason => ({ reason }));
+                    const result = yield Promise.race([packetRead, cancelled]);
+                    if ('reason' in result) {
+                        throw new Error(result.reason);
+                    }
+                    assertCurrentGeneration();
+                    frame = assembler.push(result.packet);
+                }
+                assertCurrentGeneration();
+                return frame;
+            }),
+            reset: (reason) => {
+                var _a;
+                cancellation.cancel(reason);
+                (_a = this.protocolV2UsbAssemblers.get(key)) === null || _a === void 0 ? void 0 : _a.reset();
+            },
+            logger: this.getProtocolV2UsbLogger(),
+            logPrefix: this.protocolV2UsbOptions.logPrefix,
+            createTimeoutError: (messageName, timeoutMs) => this.createProtocolV2UsbTimeoutError(messageName, timeoutMs),
+        };
+    }
+    getProtocolV2UsbAssembler(key) {
+        const assembler = this.protocolV2UsbAssemblers.get(key);
+        if (!assembler) {
+            throw new Error('Protocol V2 USB assembler has not been initialized');
+        }
+        return assembler;
+    }
+    createProtocolV2UsbCancellation(generation) {
+        let resolveCancellation = () => undefined;
+        const cancellation = {
+            generation,
+            promise: new Promise(resolve => {
+                resolveCancellation = resolve;
+            }),
+            cancel: reason => {
+                if (cancellation.reason)
+                    return;
+                cancellation.reason = reason;
+                resolveCancellation(reason);
+            },
+        };
+        return cancellation;
+    }
+}
+
 exports.AptosTransactionType = void 0;
 (function (AptosTransactionType) {
     AptosTransactionType[AptosTransactionType["STANDARD"] = 0] = "STANDARD";
@@ -500,6 +1262,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) {
@@ -609,6 +1372,9 @@ exports.FailureType = void 0;
     FailureType[FailureType["Failure_WipeCodeMismatch"] = 13] = "Failure_WipeCodeMismatch";
     FailureType[FailureType["Failure_InvalidSession"] = 14] = "Failure_InvalidSession";
     FailureType[FailureType["Failure_FirmwareError"] = 99] = "Failure_FirmwareError";
+    FailureType[FailureType["Failure_InvalidMessage"] = 1] = "Failure_InvalidMessage";
+    FailureType[FailureType["Failure_UndefinedError"] = 2] = "Failure_UndefinedError";
+    FailureType[FailureType["Failure_UsageError"] = 3] = "Failure_UsageError";
 })(exports.FailureType || (exports.FailureType = {}));
 exports.Enum_ButtonRequestType = void 0;
 (function (Enum_ButtonRequestType) {
@@ -700,6 +1466,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) {
@@ -885,6 +1654,193 @@ 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";
+    MoneroNetworkType[MoneroNetworkType["TESTNET"] = 1] = "TESTNET";
+    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";
+    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.DeviceErrorCode = void 0;
+(function (DeviceErrorCode) {
+    DeviceErrorCode[DeviceErrorCode["DeviceError_None"] = 0] = "DeviceError_None";
+    DeviceErrorCode[DeviceErrorCode["DeviceError_Busy"] = 1] = "DeviceError_Busy";
+    DeviceErrorCode[DeviceErrorCode["DeviceError_NotInitialized"] = 2] = "DeviceError_NotInitialized";
+    DeviceErrorCode[DeviceErrorCode["DeviceError_ActionCancelled"] = 3] = "DeviceError_ActionCancelled";
+    DeviceErrorCode[DeviceErrorCode["DeviceError_PinAlreadyUsed"] = 4] = "DeviceError_PinAlreadyUsed";
+    DeviceErrorCode[DeviceErrorCode["DeviceError_PersistFailed"] = 5] = "DeviceError_PersistFailed";
+    DeviceErrorCode[DeviceErrorCode["DeviceError_SeError"] = 6] = "DeviceError_SeError";
+    DeviceErrorCode[DeviceErrorCode["DeviceError_InvalidLanguage"] = 7] = "DeviceError_InvalidLanguage";
+    DeviceErrorCode[DeviceErrorCode["DeviceError_WallpaperNotUsable"] = 8] = "DeviceError_WallpaperNotUsable";
+    DeviceErrorCode[DeviceErrorCode["DeviceError_DeviceLocked"] = 9] = "DeviceError_DeviceLocked";
+})(exports.DeviceErrorCode || (exports.DeviceErrorCode = {}));
+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.DeviceSettingsPage = void 0;
+(function (DeviceSettingsPage) {
+    DeviceSettingsPage[DeviceSettingsPage["DeviceReset"] = 0] = "DeviceReset";
+    DeviceSettingsPage[DeviceSettingsPage["DevicePinChange"] = 1] = "DevicePinChange";
+    DeviceSettingsPage[DeviceSettingsPage["DevicePassphrase"] = 2] = "DevicePassphrase";
+    DeviceSettingsPage[DeviceSettingsPage["DeviceAirgap"] = 3] = "DeviceAirgap";
+})(exports.DeviceSettingsPage || (exports.DeviceSettingsPage = {}));
+exports.DeviceFirmwareTargetType = void 0;
+(function (DeviceFirmwareTargetType) {
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_INVALID"] = 0] = "FW_MGMT_TARGET_INVALID";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_CRATE"] = 1] = "FW_MGMT_TARGET_CRATE";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_ROMLOADER"] = 2] = "FW_MGMT_TARGET_ROMLOADER";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_BOOTLOADER"] = 3] = "FW_MGMT_TARGET_BOOTLOADER";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_APPLICATION_P1"] = 4] = "FW_MGMT_TARGET_APPLICATION_P1";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_APPLICATION_P2"] = 5] = "FW_MGMT_TARGET_APPLICATION_P2";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_COPROCESSOR"] = 6] = "FW_MGMT_TARGET_COPROCESSOR";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_SE01"] = 7] = "FW_MGMT_TARGET_SE01";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_SE02"] = 8] = "FW_MGMT_TARGET_SE02";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_SE03"] = 9] = "FW_MGMT_TARGET_SE03";
+    DeviceFirmwareTargetType[DeviceFirmwareTargetType["FW_MGMT_TARGET_SE04"] = 10] = "FW_MGMT_TARGET_SE04";
+})(exports.DeviceFirmwareTargetType || (exports.DeviceFirmwareTargetType = {}));
+exports.DeviceFirmwareUpdateTaskStatus = void 0;
+(function (DeviceFirmwareUpdateTaskStatus) {
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_PENDING"] = 0] = "FW_MGMT_UPDATER_TASK_STATUS_PENDING";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_IN_PROGRESS"] = 1] = "FW_MGMT_UPDATER_TASK_STATUS_IN_PROGRESS";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_FINISHED"] = 2] = "FW_MGMT_UPDATER_TASK_STATUS_FINISHED";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_FAILED_FILE_NOT_FOUND"] = 3] = "FW_MGMT_UPDATER_TASK_STATUS_FAILED_FILE_NOT_FOUND";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_FAILED_FILE_READ"] = 4] = "FW_MGMT_UPDATER_TASK_STATUS_FAILED_FILE_READ";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_FAILED_FILE_WRITE"] = 5] = "FW_MGMT_UPDATER_TASK_STATUS_FAILED_FILE_WRITE";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_FAILED_VERIFY"] = 6] = "FW_MGMT_UPDATER_TASK_STATUS_FAILED_VERIFY";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_FAILED_INSTALL"] = 7] = "FW_MGMT_UPDATER_TASK_STATUS_FAILED_INSTALL";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_FAILED_ABORT"] = 8] = "FW_MGMT_UPDATER_TASK_STATUS_FAILED_ABORT";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_FAILED_BUSY"] = 9] = "FW_MGMT_UPDATER_TASK_STATUS_FAILED_BUSY";
+    DeviceFirmwareUpdateTaskStatus[DeviceFirmwareUpdateTaskStatus["FW_MGMT_UPDATER_TASK_STATUS_FAILED_ENTRY_OUT_OF_BOUNDS"] = 10] = "FW_MGMT_UPDATER_TASK_STATUS_FAILED_ENTRY_OUT_OF_BOUNDS";
+})(exports.DeviceFirmwareUpdateTaskStatus || (exports.DeviceFirmwareUpdateTaskStatus = {}));
+exports.DeviceFactoryAck = void 0;
+(function (DeviceFactoryAck) {
+    DeviceFactoryAck[DeviceFactoryAck["FACTORY_ACK_SUCCESS"] = 0] = "FACTORY_ACK_SUCCESS";
+    DeviceFactoryAck[DeviceFactoryAck["FACTORY_ACK_FAIL"] = 1] = "FACTORY_ACK_FAIL";
+})(exports.DeviceFactoryAck || (exports.DeviceFactoryAck = {}));
+exports.DeviceType = void 0;
+(function (DeviceType) {
+    DeviceType[DeviceType["CLASSIC1"] = 0] = "CLASSIC1";
+    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";
+    DeviceType[DeviceType["PRO2"] = 7] = "PRO2";
+    DeviceType[DeviceType["NEO"] = 8] = "NEO";
+})(exports.DeviceType || (exports.DeviceType = {}));
+exports.DeviceSeType = void 0;
+(function (DeviceSeType) {
+    DeviceSeType[DeviceSeType["THD89"] = 0] = "THD89";
+    DeviceSeType[DeviceSeType["SE608A"] = 1] = "SE608A";
+})(exports.DeviceSeType || (exports.DeviceSeType = {}));
+exports.DeviceSEState = void 0;
+(function (DeviceSEState) {
+    DeviceSEState[DeviceSEState["BOOT"] = 0] = "BOOT";
+    DeviceSEState[DeviceSEState["APP_FACTORY"] = 51] = "APP_FACTORY";
+    DeviceSEState[DeviceSEState["APP"] = 85] = "APP";
+})(exports.DeviceSEState || (exports.DeviceSEState = {}));
+exports.DeviceSessionOpen_FailureSubCodes = void 0;
+(function (DeviceSessionOpen_FailureSubCodes) {
+    DeviceSessionOpen_FailureSubCodes[DeviceSessionOpen_FailureSubCodes["InvalidSession"] = 1] = "InvalidSession";
+})(exports.DeviceSessionOpen_FailureSubCodes || (exports.DeviceSessionOpen_FailureSubCodes = {}));
+exports.DeviceSessionAskPin_FailureSubCodes = void 0;
+(function (DeviceSessionAskPin_FailureSubCodes) {
+    DeviceSessionAskPin_FailureSubCodes[DeviceSessionAskPin_FailureSubCodes["UserCancel"] = 1] = "UserCancel";
+})(exports.DeviceSessionAskPin_FailureSubCodes || (exports.DeviceSessionAskPin_FailureSubCodes = {}));
+exports.DevOnboardingStep = void 0;
+(function (DevOnboardingStep) {
+    DevOnboardingStep[DevOnboardingStep["DEV_ONBOARDING_STEP_UNKNOWN"] = 0] = "DEV_ONBOARDING_STEP_UNKNOWN";
+    DevOnboardingStep[DevOnboardingStep["DEV_ONBOARDING_STEP_CHECKING"] = 1] = "DEV_ONBOARDING_STEP_CHECKING";
+    DevOnboardingStep[DevOnboardingStep["DEV_ONBOARDING_STEP_PERSONALIZATION"] = 2] = "DEV_ONBOARDING_STEP_PERSONALIZATION";
+    DevOnboardingStep[DevOnboardingStep["DEV_ONBOARDING_STEP_PIN"] = 3] = "DEV_ONBOARDING_STEP_PIN";
+    DevOnboardingStep[DevOnboardingStep["DEV_ONBOARDING_STEP_SETUP"] = 4] = "DEV_ONBOARDING_STEP_SETUP";
+    DevOnboardingStep[DevOnboardingStep["DEV_ONBOARDING_STEP_DONE"] = 5] = "DEV_ONBOARDING_STEP_DONE";
+})(exports.DevOnboardingStep || (exports.DevOnboardingStep = {}));
+exports.DevOnboardingPhase = void 0;
+(function (DevOnboardingPhase) {
+    DevOnboardingPhase[DevOnboardingPhase["DEV_ONBOARDING_PHASE_UNKNOWN"] = 0] = "DEV_ONBOARDING_PHASE_UNKNOWN";
+    DevOnboardingPhase[DevOnboardingPhase["DEV_ONBOARDING_PHASE_SAFETY_CHECK"] = 1] = "DEV_ONBOARDING_PHASE_SAFETY_CHECK";
+    DevOnboardingPhase[DevOnboardingPhase["DEV_ONBOARDING_PHASE_PIN_SETUP"] = 2] = "DEV_ONBOARDING_PHASE_PIN_SETUP";
+    DevOnboardingPhase[DevOnboardingPhase["DEV_ONBOARDING_PHASE_FINGERPRINT_SETUP"] = 3] = "DEV_ONBOARDING_PHASE_FINGERPRINT_SETUP";
+    DevOnboardingPhase[DevOnboardingPhase["DEV_ONBOARDING_PHASE_SETUP_CHOICE"] = 4] = "DEV_ONBOARDING_PHASE_SETUP_CHOICE";
+    DevOnboardingPhase[DevOnboardingPhase["DEV_ONBOARDING_PHASE_WALLET_CREATE_START"] = 5] = "DEV_ONBOARDING_PHASE_WALLET_CREATE_START";
+    DevOnboardingPhase[DevOnboardingPhase["DEV_ONBOARDING_PHASE_RECOVERY_PHRASE_VIEW"] = 6] = "DEV_ONBOARDING_PHASE_RECOVERY_PHRASE_VIEW";
+    DevOnboardingPhase[DevOnboardingPhase["DEV_ONBOARDING_PHASE_RECOVERY_PHRASE_CONFIRM"] = 7] = "DEV_ONBOARDING_PHASE_RECOVERY_PHRASE_CONFIRM";
+    DevOnboardingPhase[DevOnboardingPhase["DEV_ONBOARDING_PHASE_RESTORE_METHOD_CHOICE"] = 8] = "DEV_ONBOARDING_PHASE_RESTORE_METHOD_CHOICE";
+    DevOnboardingPhase[DevOnboardingPhase["DEV_ONBOARDING_PHASE_RECOVERY_PHRASE_RESTORE"] = 9] = "DEV_ONBOARDING_PHASE_RECOVERY_PHRASE_RESTORE";
+    DevOnboardingPhase[DevOnboardingPhase["DEV_ONBOARDING_PHASE_SEEDCARD_RESTORE"] = 10] = "DEV_ONBOARDING_PHASE_SEEDCARD_RESTORE";
+    DevOnboardingPhase[DevOnboardingPhase["DEV_ONBOARDING_PHASE_WALLET_READY"] = 11] = "DEV_ONBOARDING_PHASE_WALLET_READY";
+    DevOnboardingPhase[DevOnboardingPhase["DEV_ONBOARDING_PHASE_SEEDCARD_BACKUP_PROMPT"] = 12] = "DEV_ONBOARDING_PHASE_SEEDCARD_BACKUP_PROMPT";
+    DevOnboardingPhase[DevOnboardingPhase["DEV_ONBOARDING_PHASE_SEEDCARD_BACKUP"] = 13] = "DEV_ONBOARDING_PHASE_SEEDCARD_BACKUP";
+})(exports.DevOnboardingPhase || (exports.DevOnboardingPhase = {}));
+exports.DevOnboardingSetupKind = void 0;
+(function (DevOnboardingSetupKind) {
+    DevOnboardingSetupKind[DevOnboardingSetupKind["DEV_ONBOARDING_SETUP_KIND_UNKNOWN"] = 0] = "DEV_ONBOARDING_SETUP_KIND_UNKNOWN";
+    DevOnboardingSetupKind[DevOnboardingSetupKind["DEV_ONBOARDING_SETUP_KIND_CHOICE"] = 1] = "DEV_ONBOARDING_SETUP_KIND_CHOICE";
+    DevOnboardingSetupKind[DevOnboardingSetupKind["DEV_ONBOARDING_SETUP_KIND_CREATE"] = 2] = "DEV_ONBOARDING_SETUP_KIND_CREATE";
+    DevOnboardingSetupKind[DevOnboardingSetupKind["DEV_ONBOARDING_SETUP_KIND_RESTORE"] = 3] = "DEV_ONBOARDING_SETUP_KIND_RESTORE";
+})(exports.DevOnboardingSetupKind || (exports.DevOnboardingSetupKind = {}));
+exports.DevOnboardingSetupMethod = void 0;
+(function (DevOnboardingSetupMethod) {
+    DevOnboardingSetupMethod[DevOnboardingSetupMethod["DEV_ONBOARDING_SETUP_METHOD_UNKNOWN"] = 0] = "DEV_ONBOARDING_SETUP_METHOD_UNKNOWN";
+    DevOnboardingSetupMethod[DevOnboardingSetupMethod["DEV_ONBOARDING_SETUP_METHOD_RECOVERY_PHRASE"] = 1] = "DEV_ONBOARDING_SETUP_METHOD_RECOVERY_PHRASE";
+    DevOnboardingSetupMethod[DevOnboardingSetupMethod["DEV_ONBOARDING_SETUP_METHOD_SEEDCARD"] = 2] = "DEV_ONBOARDING_SETUP_METHOD_SEEDCARD";
+})(exports.DevOnboardingSetupMethod || (exports.DevOnboardingSetupMethod = {}));
+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,
@@ -950,28 +1906,89 @@ 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 WallpaperTarget () { return exports.WallpaperTarget; },
+    get MoneroNetworkType () { return exports.MoneroNetworkType; },
+    get ViewTipType () { return exports.ViewTipType; },
+    get ViewSignLayout () { return exports.ViewSignLayout; },
+    get DeviceErrorCode () { return exports.DeviceErrorCode; },
+    get DeviceRebootType () { return exports.DeviceRebootType; },
+    get DeviceSettingsPage () { return exports.DeviceSettingsPage; },
+    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 DeviceSessionOpen_FailureSubCodes () { return exports.DeviceSessionOpen_FailureSubCodes; },
+    get DeviceSessionAskPin_FailureSubCodes () { return exports.DeviceSessionAskPin_FailureSubCodes; },
+    get DevOnboardingStep () { return exports.DevOnboardingStep; },
+    get DevOnboardingPhase () { return exports.DevOnboardingPhase; },
+    get DevOnboardingSetupKind () { return exports.DevOnboardingSetupKind; },
+    get DevOnboardingSetupMethod () { return exports.DevOnboardingSetupMethod; },
+    get ProtocolV2FailureType () { return exports.ProtocolV2FailureType; },
+    get Enum_ProtocolV2Capability () { return exports.Enum_ProtocolV2Capability; }
 });
 
-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,
+    ProtocolV2LinkManager,
+    ProtocolV2SequenceCursor,
+    ProtocolV2Session,
+    ProtocolV2UsbTransportBase,
+    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_BLE_FILE_READ_CHUNK_SIZE = PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE;
+exports.PROTOCOL_V2_BLE_FRAME_MAX_BYTES = PROTOCOL_V2_BLE_FRAME_MAX_BYTES;
+exports.PROTOCOL_V2_CHANNEL_BLE_UART = PROTOCOL_V2_CHANNEL_BLE_UART;
+exports.PROTOCOL_V2_CHANNEL_SOCKET = PROTOCOL_V2_CHANNEL_SOCKET;
+exports.PROTOCOL_V2_CHANNEL_USB = PROTOCOL_V2_CHANNEL_USB;
+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.ProtocolV2LinkManager = ProtocolV2LinkManager;
+exports.ProtocolV2SequenceCursor = ProtocolV2SequenceCursor;
+exports.ProtocolV2Session = ProtocolV2Session;
+exports.ProtocolV2UsbTransportBase = ProtocolV2UsbTransportBase;
+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;