chore(protocol): rename decode response fields

- `typeId` => `messageType`
- `buffer` => `payload`

packages/protocol/src/protocol-bridge/decode.ts

@@ -6,20 +6,20 @@ import { TransportProtocolDecode } from '../types';
  */
 const readHeader = (buffer: Buffer) => {
     // 2 bytes
-    const typeId = buffer.readUInt16BE();
+    const messageType = buffer.readUInt16BE();
     // 4 bytes
     const length = buffer.readUInt32BE(2);
 
-    return { typeId, length };
+    return { messageType, length };
 };
 
 export const decode: TransportProtocolDecode = bytes => {
     const buffer = Buffer.from(bytes);
-    const { typeId, length } = readHeader(buffer);
+    const { messageType, length } = readHeader(buffer);
 
     return {
-        typeId,
+        messageType,
         length,
-        buffer: buffer.subarray(HEADER_SIZE),
+        payload: buffer.subarray(HEADER_SIZE),
     };
 };

packages/protocol/src/protocol-v1/decode.ts

@@ -13,18 +13,18 @@ const readHeaderChunked = (buffer: Buffer) => {
     // 1 byte
     const sharp2 = buffer.readUInt8(2);
     // 2 bytes
-    const typeId = buffer.readUInt16BE(3);
+    const messageType = buffer.readUInt16BE(3);
     // 4 bytes
     const length = buffer.readUInt32BE(5);
 
-    return { magic, sharp1, sharp2, typeId, length };
+    return { magic, sharp1, sharp2, messageType, length };
 };
 
 // Parses first raw input that comes from Trezor and returns some information about the whole message.
 // [compatibility]: accept Buffer just like decode does. But this would require changes in lower levels
 export const decode: TransportProtocolDecode = bytes => {
     const buffer = Buffer.from(bytes);
-    const { magic, sharp1, sharp2, typeId, length } = readHeaderChunked(buffer);
+    const { magic, sharp1, sharp2, messageType, length } = readHeaderChunked(buffer);
 
     if (
         magic !== MESSAGE_MAGIC_HEADER_BYTE ||
@@ -37,7 +37,7 @@ export const decode: TransportProtocolDecode = bytes => {
 
     return {
         length,
-        typeId,
-        buffer: buffer.subarray(HEADER_SIZE + 1), // each chunk is prefixed by magic byte
+        messageType,
+        payload: buffer.subarray(HEADER_SIZE + 1), // each chunk is prefixed by magic byte
     };
 };

packages/protocol/src/types.ts

@@ -1,7 +1,7 @@
 export type TransportProtocolDecode = (bytes: ArrayBuffer) => {
     length: number;
-    typeId: number;
-    buffer: Buffer;
+    messageType: number;
+    payload: Buffer;
 };
 
 export interface TransportProtocolEncodeOptions {

packages/protocol/tests/protocol-bridge.test.ts

@@ -23,7 +23,7 @@ describe('protocol-bridge', () => {
         data.writeUint32BE(379, 2);
 
         const read = bridge.decode(data);
-        expect(read.typeId).toEqual(55);
+        expect(read.messageType).toEqual(55);
         expect(read.length).toEqual(379);
     });
 });

packages/protocol/tests/protocol-v1.test.ts

@@ -31,7 +31,7 @@ describe('protocol-v1', () => {
         data.writeUint32BE(379, 5);
 
         const read = v1.decode(data);
-        expect(read.typeId).toEqual(55);
+        expect(read.messageType).toEqual(55);
         expect(read.length).toEqual(379);
     });
 });

packages/transport-bridge/src/core.ts

@@ -37,13 +37,11 @@ export const createApi = (apiStr: 'usb' | 'udp', logger?: Log) => {
     });
 
     const writeUtil = async ({ path, data }: { path: string; data: string }) => {
-        const { typeId, buffer: restBuffer } = protocolBridge.decode(
+        const { messageType, payload } = protocolBridge.decode(
             new Uint8Array(Buffer.from(data, 'hex')),
         );
 
-        const buffers = protocolV1.encode(restBuffer, {
-            messageType: typeId,
-        });
+        const buffers = protocolV1.encode(payload, { messageType });
 
         for (let i = 0; i < buffers.length; i++) {
             const bufferSegment = buffers[i];
@@ -59,7 +57,7 @@ export const createApi = (apiStr: 'usb' | 'udp', logger?: Log) => {
 
     const readUtil = async ({ path }: { path: string }) => {
         try {
-            const message = await receiveUtil(
+            const { messageType, payload } = await receiveUtil(
                 () =>
                     api.read(path).then(result => {
                         if (result.success) {
@@ -72,9 +70,7 @@ export const createApi = (apiStr: 'usb' | 'udp', logger?: Log) => {
 
             return {
                 success: true as const,
-                payload: protocolBridge
-                    .encode(message.buffer, { messageType: message.typeId })[0]
-                    .toString('hex'),
+                payload: protocolBridge.encode(payload, { messageType })[0].toString('hex'),
             };
         } catch (err) {
             return { success: false as const, error: err.message as string };

packages/transport/src/utils/receive.ts

@@ -28,27 +28,27 @@ async function receiveBuffer(
     decoder: TransportProtocolDecode,
 ) {
     const data = await receiver();
-    const { length, typeId, buffer } = decoder(data);
+    const { length, messageType, payload } = decoder(data);
     const result = Buffer.alloc(length);
 
     if (length) {
-        buffer.copy(result);
+        payload.copy(result);
     }
 
-    await receiveRest(result, receiver, buffer.length, length);
+    await receiveRest(result, receiver, payload.length, length);
 
-    return { received: result, typeId };
+    return { messageType, payload: result };
 }
 
 export async function receive(
     receiver: () => Promise<ArrayBuffer>,
     decoder: TransportProtocolDecode,
 ) {
-    const { received, typeId } = await receiveBuffer(receiver, decoder);
+    const { payload, messageType } = await receiveBuffer(receiver, decoder);
 
     return {
-        typeId,
-        buffer: received,
+        messageType,
+        payload,
     };
 }
 
@@ -57,9 +57,9 @@ export async function receiveAndParse(
     receiver: () => Promise<ArrayBuffer>,
     decoder: TransportProtocolDecode,
 ) {
-    const { buffer, typeId } = await receive(receiver, decoder);
-    const { Message, messageName } = createMessageFromType(messages, typeId);
-    const message = decodeProtobuf(Message, buffer);
+    const { messageType, payload } = await receive(receiver, decoder);
+    const { Message, messageName } = createMessageFromType(messages, messageType);
+    const message = decodeProtobuf(Message, payload);
 
     return {
         message,