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

package/dist/index.js

@@ -28,7 +28,7 @@ function _interopNamespace(e) {
 }
 
 var protobuf__namespace = /*#__PURE__*/_interopNamespace(protobuf);
-var Long__default = /*#__PURE__*/_interopDefaultLegacy(Long);
+var Long__namespace = /*#__PURE__*/_interopNamespace(Long);
 var ByteBuffer__default = /*#__PURE__*/_interopDefaultLegacy(ByteBuffer);
 
 /******************************************************************************
@@ -58,16 +58,6 @@ 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;
@@ -113,12 +103,6 @@ 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));
@@ -148,7 +132,7 @@ function messageToJSON(Message, fields) {
     });
     return res;
 }
-const decode = (Message, data) => {
+const decode$1 = (Message, data) => {
     const buff = data.toBuffer();
     const a = new Uint8Array(buff);
     let decoded;
@@ -216,7 +200,7 @@ function patch(Message, payload) {
     });
     return patched;
 }
-const encode = (Message, data) => {
+const encode$1 = (Message, data) => {
     const payload = patch(Message, data);
     const message = Message.fromObject(payload);
     const buffer = Message.encode(message).finish();
@@ -235,25 +219,18 @@ function parseConfigure(data) {
 const createMessageFromName = (messages, name) => {
     const Message = messages.lookupType(name);
     const MessageType = messages.lookupEnum('MessageType');
-    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`);
+    let messageType = MessageType.values[`MessageType_${name}`];
+    if (!messageType && Message.options) {
+        messageType = Message.options['(wire_type)'];
     }
     return {
         Message,
-        messageTypeId,
+        messageType,
     };
 };
 const createMessageFromType = (messages, typeId) => {
     const MessageType = messages.lookupEnum('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 messageName = MessageType.valuesById[typeId].replace('MessageType_', '');
     const Message = messages.lookupType(messageName);
     return {
         Message,
@@ -261,33 +238,55 @@ const createMessageFromType = (messages, typeId) => {
     };
 };
 
-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;
+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
+});
 
-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);
+function encode(data, options) {
+    const { addTrezorHeaders, chunked, messageType } = options;
+    const fullSize = (addTrezorHeaders ? HEADER_SIZE : HEADER_SIZE - 2) + data.limit;
     const encodedByteBuffer = new ByteBuffer__default["default"](fullSize);
     if (addTrezorHeaders) {
-        encodedByteBuffer.writeByte(PROTOCOL_V1_HEADER_BYTE);
-        encodedByteBuffer.writeByte(PROTOCOL_V1_HEADER_BYTE);
+        encodedByteBuffer.writeByte(MESSAGE_HEADER_BYTE);
+        encodedByteBuffer.writeByte(MESSAGE_HEADER_BYTE);
     }
-    encodedByteBuffer.writeUint16(messageTypeId);
+    encodedByteBuffer.writeUint16(messageType);
     encodedByteBuffer.writeUint32(data.limit);
     encodedByteBuffer.append(data.buffer);
     encodedByteBuffer.reset();
@@ -295,7 +294,7 @@ function encodeEnvelope(data, options) {
         return encodedByteBuffer;
     }
     const result = [];
-    const size = PROTOCOL_V1_CHUNK_PAYLOAD_SIZE;
+    const size = BUFFER_SIZE;
     const count = Math.floor((encodedByteBuffer.limit - 1) / size) + 1 || 1;
     for (let i = 0; i < count; i++) {
         const start = i * size;
@@ -307,30 +306,30 @@ function encodeEnvelope(data, options) {
     return result;
 }
 
-function encodeEnvelopeMessage(messages, name, data) {
-    const { Message, messageTypeId } = createMessageFromName(messages, name);
-    const buffer = encode(Message, data);
-    return encodeEnvelope(buffer, {
+function buildOne(messages, name, data) {
+    const { Message, messageType } = createMessageFromName(messages, name);
+    const buffer = encode$1(Message, data);
+    return encode(buffer, {
         addTrezorHeaders: false,
         chunked: false,
-        messageTypeId,
+        messageType,
     });
 }
-const encodeMessageChunks = (messages, name, data) => {
-    const { Message, messageTypeId } = createMessageFromName(messages, name);
-    const buffer = encode(Message, data);
-    return encodeEnvelope(buffer, {
+const buildEncodeBuffers = (messages, name, data) => {
+    const { Message, messageType } = createMessageFromName(messages, name);
+    const buffer = encode$1(Message, data);
+    return encode(buffer, {
         addTrezorHeaders: true,
         chunked: true,
-        messageTypeId,
+        messageType,
     });
 };
-const encodeTransportPackets = (messages, name, data) => {
-    const encodeBuffers = encodeMessageChunks(messages, name, data);
+const buildBuffers = (messages, name, data) => {
+    const encodeBuffers = buildEncodeBuffers(messages, name, data);
     const outBuffers = [];
     for (const buf of encodeBuffers) {
-        const chunkBuffer = new ByteBuffer__default["default"](PROTOCOL_V1_CHUNK_PAYLOAD_SIZE + 1);
-        chunkBuffer.writeByte(PROTOCOL_V1_REPORT_ID);
+        const chunkBuffer = new ByteBuffer__default["default"](BUFFER_SIZE + 1);
+        chunkBuffer.writeByte(MESSAGE_TOP_CHAR);
         chunkBuffer.append(buf);
         chunkBuffer.reset();
         outBuffers.push(chunkBuffer);
@@ -338,359 +337,17 @@ const encodeTransportPackets = (messages, name, data) => {
     return outBuffers;
 };
 
-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) {
+function receiveOne(messages, data) {
     const bytebuffer = ByteBuffer__default["default"].wrap(data, 'hex');
-    const { typeId, buffer } = decodeEnvelope(bytebuffer);
+    const { typeId, buffer } = decode(bytebuffer);
     const { Message, messageName } = createMessageFromType(messages, typeId);
-    const message = decode(Message, buffer);
+    const message = decode$1(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) {
@@ -778,425 +435,6 @@ 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";
@@ -1262,7 +500,6 @@ 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) {
@@ -1372,9 +609,6 @@ 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) {
@@ -1466,9 +700,6 @@ 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) {
@@ -1654,193 +885,6 @@ exports.CommandFlags = void 0;
     CommandFlags[CommandFlags["Default"] = 0] = "Default";
     CommandFlags[CommandFlags["Factory_Only"] = 1] = "Factory_Only";
 })(exports.CommandFlags || (exports.CommandFlags = {}));
-exports.WallpaperTarget = void 0;
-(function (WallpaperTarget) {
-    WallpaperTarget[WallpaperTarget["Home"] = 0] = "Home";
-    WallpaperTarget[WallpaperTarget["Lock"] = 1] = "Lock";
-})(exports.WallpaperTarget || (exports.WallpaperTarget = {}));
-exports.MoneroNetworkType = void 0;
-(function (MoneroNetworkType) {
-    MoneroNetworkType[MoneroNetworkType["MAINNET"] = 0] = "MAINNET";
-    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,
@@ -1906,89 +950,28 @@ 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 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; }
+    get CommandFlags () { return exports.CommandFlags; }
 });
 
-protobuf__namespace.util.Long = Long__default["default"];
+const LogBlockCommand = new Set(['PassphraseAck', 'PinMatrixAck']);
+
+protobuf__namespace.util.Long = Long__namespace;
 protobuf__namespace.configure();
 var index = {
     check,
+    buildOne,
+    buildBuffers,
+    buildEncodeBuffers,
+    receiveOne,
     parseConfigure,
-    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,
+    decodeProtocol,
 };
 
+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;