@ukeyfe/hardware-transport 1.1.13

package/src/serialization/protobuf/decode.ts

@@ -0,0 +1,95 @@
+import { Type, Message, Field } from 'protobufjs/light';
+import ByteBuffer from 'bytebuffer';
+import { isPrimitiveField } from '../../utils/protobuf';
+
+const transform = (field: Field, value: any) => {
+  // [compatibility]: optional undefined keys should be null. Example: Features.fw_major.
+  if (field?.optional && typeof value === 'undefined') {
+    return null;
+  }
+
+  if (field?.type === 'bytes') {
+    return ByteBuffer.wrap(value).toString('hex');
+    // return value.toString('hex');
+  }
+
+  // [compatibility]
+  // it is likely that we can remove this right away because trezor-connect tests don't ever trigger this condition
+  // we should probably make sure that trezor-connect treats following protobuf types as strings: int64, uint64, sint64, fixed64, sfixed64
+  if (field?.long) {
+    if (Number.isSafeInteger(value.toNumber())) {
+      // old trezor-link behavior https://github.com/trezor/trezor-link/blob/9c200cc5608976cff0542484525e98c753ba1888/src/lowlevel/protobuf/message_decoder.js#L80
+      return value.toNumber();
+    }
+    // otherwise return as string
+    return value.toString();
+  }
+
+  return value;
+};
+
+function messageToJSON(Message: Message<Record<string, unknown>>, fields: Type['fields']) {
+  // get rid of Message.prototype references
+  const { ...message } = Message;
+  const res: { [key: string]: any } = {};
+
+  Object.keys(fields).forEach(key => {
+    const field = fields[key];
+    // @ts-ignore
+    const value = message[key];
+
+    /* istanbul ignore else  */
+    if (field.repeated) {
+      /* istanbul ignore else  */
+      if (isPrimitiveField(field.type)) {
+        res[key] = value.map((v: any) => transform(field, v));
+      }
+      // [compatibility]: keep array enums as array of numbers.
+      else if ('valuesById' in field.resolvedType!) {
+        res[key] = value;
+      } else if ('fields' in field.resolvedType!) {
+        res[key] = value.map((v: any) => messageToJSON(v, (field.resolvedType as Type).fields));
+      } else {
+        throw new Error(`case not handled for repeated key: ${key}`);
+      }
+    } else if (isPrimitiveField(field.type)) {
+      res[key] = transform(field, value);
+    }
+    // enum type
+    else if ('valuesById' in field.resolvedType!) {
+      res[key] = field.resolvedType.valuesById[value];
+    }
+    // message type
+    else if (field.resolvedType!.fields) {
+      res[key] = messageToJSON(value, field.resolvedType!.fields);
+    } else {
+      throw new Error(`case not handled: ${key}`);
+    }
+  });
+
+  return res;
+}
+
+export const decode = (Message: Type, data: ByteBuffer) => {
+  const buff = data.toBuffer();
+  const a = new Uint8Array(buff);
+
+  let decoded;
+  try {
+    decoded = Message.decode(a);
+  } catch (error) {
+    // Fix a battery_level problem with the device
+    if (a.length > 1 && a[a.length - 1] === 0xff) {
+      a[a.length - 1] = 0x04;
+      decoded = Message.decode(a);
+    } else {
+      throw error;
+    }
+  }
+
+  // [compatibility]: in the end it should be possible to get rid of messageToJSON method and call
+  // Message.toObject(decoded) to return result as plain javascript object. This method should be able to do
+  // all required conversions (for example bytes to hex) but we can't use it at the moment for compatibility reasons
+  // for example difference between enum decoding when [enum] vs enum
+  return messageToJSON(decoded, decoded.$type.fields);
+};

package/src/serialization/protobuf/encode.ts

@@ -0,0 +1,79 @@
+import { Type } from 'protobufjs/light';
+import { Buffer } from 'buffer';
+import ByteBuffer from 'bytebuffer';
+
+import { isPrimitiveField } from '../../utils/protobuf';
+
+const transform = (fieldType: string, value: any) => {
+  if (fieldType === 'bytes') {
+    // special edge case
+    // for example MultisigRedeemScriptType might have field signatures ['', '', ''] (check in TrezorConnect signTransactionMultisig test fixtures).
+    // trezor needs to receive such field as signatures: [b'', b'', b'']. If we transfer this to empty buffer with protobufjs, this will be decoded by
+    // trezor as signatures: [] (empty array)
+    if (typeof value === 'string' && !value) return value;
+
+    // normal flow
+    return Buffer.from(value, 'hex');
+  }
+  if (typeof value === 'number' && !Number.isSafeInteger(value)) {
+    throw new RangeError('field value is not within safe integer range');
+  }
+  return value;
+};
+
+export function patch(Message: Type, payload: any) {
+  const patched: any = {};
+
+  if (!Message.fields) {
+    return patched;
+  }
+
+  Object.keys(Message.fields).forEach(key => {
+    const field = Message.fields[key];
+    const value = payload[key];
+
+    // no value for this field
+    if (typeof value === 'undefined') {
+      return;
+    }
+    // primitive type
+    if (field && isPrimitiveField(field.type)) {
+      if (field.repeated) {
+        patched[key] = value.map((v: any) => transform(field.type, v));
+      } else {
+        patched[key] = transform(field.type, value);
+      }
+      return;
+    }
+    // repeated
+    if (field.repeated) {
+      const RefMessage = Message.lookupTypeOrEnum(field.type);
+      patched[key] = value.map((v: any) => patch(RefMessage, v));
+    }
+    // message type
+    else if (typeof value === 'object' && value !== null) {
+      const RefMessage = Message.lookupType(field.type);
+      patched[key] = patch(RefMessage, value);
+    }
+    // enum type
+    else if (typeof value === 'number') {
+      const RefMessage = Message.lookupEnum(field.type);
+      patched[key] = RefMessage.values[value];
+    } else {
+      patched[key] = value;
+    }
+  });
+
+  return patched;
+}
+
+export const encode = (Message: Type, data: Record<string, unknown>) => {
+  const payload = patch(Message, data);
+  const message = Message.fromObject(payload);
+  // Encode a message to an Uint8Array (browser) or Buffer (node)
+  const buffer = Message.encode(message).finish();
+  const bytebuffer = new ByteBuffer(buffer.byteLength);
+  bytebuffer.append(buffer);
+  bytebuffer.reset();
+  return bytebuffer;
+};

package/src/serialization/protobuf/index.ts

@@ -0,0 +1,3 @@
+export * from './decode';
+export * from './encode';
+export * from './messages';

package/src/serialization/protobuf/messages.ts

@@ -0,0 +1,37 @@
+import * as protobuf from 'protobufjs/light';
+
+export function parseConfigure(data: protobuf.INamespace) {
+  // @ts-ignore [compatiblity]: connect is sending stringified json
+  if (typeof data === 'string') {
+    return protobuf.Root.fromJSON(JSON.parse(data));
+  }
+  return protobuf.Root.fromJSON(data);
+}
+
+export const createMessageFromName = (messages: protobuf.Root, name: string) => {
+  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)'];
+  }
+
+  return {
+    Message,
+    messageType,
+  };
+};
+
+export const createMessageFromType = (messages: protobuf.Root, typeId: number) => {
+  const MessageType = messages.lookupEnum('MessageType');
+
+  const messageName = MessageType.valuesById[typeId].replace('MessageType_', '');
+
+  const Message = messages.lookupType(messageName);
+
+  return {
+    Message,
+    messageName,
+  };
+};

package/src/serialization/protocol/decode.ts

@@ -0,0 +1,48 @@
+import ByteBuffer from 'bytebuffer';
+import { MESSAGE_HEADER_BYTE } from '../../constants';
+
+/**
+ * Reads meta information from buffer
+ */
+const readHeader = (buffer: ByteBuffer) => {
+  const typeId = buffer.readUint16();
+  const length = buffer.readUint32();
+
+  return { typeId, length };
+};
+
+/**
+ * Reads meta information from chunked buffer
+ */
+const readHeaderChunked = (buffer: ByteBuffer) => {
+  const sharp1 = buffer.readByte();
+  const sharp2 = buffer.readByte();
+  const typeId = buffer.readUint16();
+  const length = buffer.readUint32();
+
+  return { sharp1, sharp2, typeId, length };
+};
+
+export const decode = (byteBuffer: ByteBuffer) => {
+  const { typeId } = readHeader(byteBuffer);
+
+  return {
+    typeId,
+    buffer: byteBuffer,
+  };
+};
+
+// 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 decodeChunked = (bytes: ArrayBuffer) => {
+  // convert to ByteBuffer so it's easier to read
+  const byteBuffer = ByteBuffer.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 };
+};

package/src/serialization/protocol/encode.ts

@@ -0,0 +1,59 @@
+import ByteBuffer from 'bytebuffer';
+
+import { HEADER_SIZE, MESSAGE_HEADER_BYTE, BUFFER_SIZE } from '../../constants';
+
+type Options<Chunked> = {
+  chunked: Chunked;
+  addTrezorHeaders: boolean;
+  messageType: number;
+};
+
+function encode(data: ByteBuffer, options: Options<true>): Buffer[];
+function encode(data: ByteBuffer, options: Options<false>): Buffer;
+function encode(data: any, options: any): any {
+  const { addTrezorHeaders, chunked, messageType } = options;
+  // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+  const fullSize = (addTrezorHeaders ? HEADER_SIZE : HEADER_SIZE - 2) + data.limit;
+
+  const encodedByteBuffer = new ByteBuffer(fullSize);
+
+  if (addTrezorHeaders) {
+    // 2*1 byte
+    encodedByteBuffer.writeByte(MESSAGE_HEADER_BYTE);
+    encodedByteBuffer.writeByte(MESSAGE_HEADER_BYTE);
+  }
+
+  // 2 bytes
+  encodedByteBuffer.writeUint16(messageType);
+
+  // 4 bytes (so 8 in total)
+  encodedByteBuffer.writeUint32(data.limit);
+
+  // then put in the actual message
+  encodedByteBuffer.append(data.buffer);
+
+  encodedByteBuffer.reset();
+
+  if (chunked === false) {
+    return encodedByteBuffer;
+  }
+
+  const result: Buffer[] = [];
+  const size = BUFFER_SIZE;
+
+  // How many pieces will there actually be
+  const count = Math.floor((encodedByteBuffer.limit - 1) / size) + 1 || 1;
+
+  // slice and dice
+  for (let i = 0; i < count; i++) {
+    const start = i * size;
+    const end = Math.min((i + 1) * size, encodedByteBuffer.limit);
+    const slice = encodedByteBuffer.slice(start, end);
+    slice.compact();
+    result.push(slice.buffer);
+  }
+
+  return result;
+}
+
+export { encode };

package/src/serialization/protocol/index.ts

@@ -0,0 +1,2 @@
+export * from './decode';
+export * from './encode';

package/src/serialization/receive.ts

@@ -0,0 +1,18 @@
+import { Root } from 'protobufjs/light';
+import ByteBuffer from 'bytebuffer';
+
+import * as decodeProtobuf from './protobuf/decode';
+import * as decodeProtocol from './protocol/decode';
+import { createMessageFromType } from './protobuf/messages';
+
+export function receiveOne(messages: Root, data: string) {
+  const bytebuffer = ByteBuffer.wrap(data, 'hex');
+
+  const { typeId, buffer } = decodeProtocol.decode(bytebuffer);
+  const { Message, messageName } = createMessageFromType(messages, typeId);
+  const message = decodeProtobuf.decode(Message, buffer);
+  return {
+    message,
+    type: messageName,
+  };
+}

package/src/serialization/send.ts

@@ -0,0 +1,56 @@
+// Logic of sending data to trezor
+//
+// Logic of "call" is broken to two parts - sending and receiving
+import { Root } from 'protobufjs/light';
+import ByteBuffer from 'bytebuffer';
+import { encode as encodeProtobuf } from './protobuf';
+import { encode as encodeProtocol } from './protocol';
+import { createMessageFromName } from './protobuf/messages';
+import { BUFFER_SIZE, MESSAGE_TOP_CHAR } from '../constants';
+
+// Sends message to device.
+// Resolves if everything gets sent
+export function buildOne(messages: Root, name: string, data: Record<string, unknown>) {
+  const { Message, messageType } = createMessageFromName(messages, name);
+
+  const buffer = encodeProtobuf(Message, data);
+  return encodeProtocol(buffer, {
+    addTrezorHeaders: false,
+    chunked: false,
+    messageType,
+  });
+}
+
+export const buildEncodeBuffers = (messages: Root, name: string, data: Record<string, unknown>) => {
+  const { Message, messageType } = createMessageFromName(messages, name);
+  const buffer = encodeProtobuf(Message, data);
+  return encodeProtocol(buffer, {
+    addTrezorHeaders: true,
+    chunked: true,
+    messageType,
+  });
+};
+
+export const buildBuffers = (messages: Root, name: string, data: Record<string, unknown>) => {
+  // const { Message, messageType } = createMessageFromName(messages, name);
+  // const buffer = encodeProtobuf(Message, data);
+  // const encodeBuffers = encodeProtocol(buffer, {
+  //   addTrezorHeaders: true,
+  //   chunked: true,
+  //   messageType,
+  // });
+
+  const encodeBuffers = buildEncodeBuffers(messages, name, data);
+
+  const outBuffers: ByteBuffer[] = [];
+
+  for (const buf of encodeBuffers) {
+    const chunkBuffer = new ByteBuffer(BUFFER_SIZE + 1);
+    chunkBuffer.writeByte(MESSAGE_TOP_CHAR);
+    chunkBuffer.append(buf);
+    chunkBuffer.reset();
+    outBuffers.push(chunkBuffer);
+  }
+
+  return outBuffers;
+};

package/src/types/index.ts

@@ -0,0 +1,2 @@
+export * from './transport';
+export * as Messages from './messages';