@onekeyfe/hd-transport 1.2.0-alpha.20 → 1.2.0-alpha.22

package/messages-protocol-v2.json

@@ -482,9 +482,9 @@
         "MessageType_DeviceStatus": 60603,
         "MessageType_DevGetOnboardingStatus": 60604,
         "MessageType_DevOnboardingStatus": 60605,
-        "MessageType_DeviceSessionGet": 60606,
         "MessageType_DeviceSession": 60607,
         "MessageType_DeviceSessionAskPin": 60608,
+        "MessageType_DeviceSessionOpen": 60609,
         "MessageType_FilesystemPermissionFix": 60800,
         "MessageType_FilesystemPathInfo": 60801,
         "MessageType_FilesystemPathInfoQuery": 60802,
@@ -506,7 +506,8 @@
         [90, 92],
         [114, 122],
         [300, 304],
-        [309, 312]
+        [309, 312],
+        [60606, 60606]
       ]
     },
     "AlephiumGetAddress": {
@@ -11744,7 +11745,15 @@
       }
     },
     "ProtocolInfoRequest": {
-      "fields": {}
+      "fields": {
+        "eventless_wallet_session": {
+          "type": "bool",
+          "id": 1,
+          "options": {
+            "default": false
+          }
+        }
+      }
     },
     "ProtocolInfo": {
       "fields": {
@@ -12427,14 +12436,78 @@
         }
       }
     },
-    "DeviceSessionGet": {
+    "DeviceSessionErrorCode": {
+      "values": {
+        "DeviceSessionError_None": 0,
+        "DeviceSessionError_UserCancelled": 1,
+        "DeviceSessionError_InvalidSession": 2,
+        "DeviceSessionError_AttachPinUnavailable": 3,
+        "DeviceSessionError_PassphraseDisabled": 4,
+        "DeviceSessionError_Busy": 5
+      }
+    },
+    "DeviceSessionResume": {
       "fields": {
         "session_id": {
+          "rule": "required",
           "type": "bytes",
           "id": 1
         }
       }
     },
+    "DeviceSessionHostPassphrase": {
+      "fields": {
+        "passphrase": {
+          "rule": "required",
+          "type": "string",
+          "id": 1
+        }
+      }
+    },
+    "DeviceSessionPassphraseOnDevice": {
+      "fields": {}
+    },
+    "DeviceSessionAttachPinOnDevice": {
+      "fields": {}
+    },
+    "DeviceSessionSelect": {
+      "oneofs": {
+        "access": {
+          "oneof": ["host_passphrase", "passphrase_on_device", "attach_pin_on_device"]
+        }
+      },
+      "fields": {
+        "host_passphrase": {
+          "type": "DeviceSessionHostPassphrase",
+          "id": 1
+        },
+        "passphrase_on_device": {
+          "type": "DeviceSessionPassphraseOnDevice",
+          "id": 2
+        },
+        "attach_pin_on_device": {
+          "type": "DeviceSessionAttachPinOnDevice",
+          "id": 3
+        }
+      }
+    },
+    "DeviceSessionOpen": {
+      "oneofs": {
+        "mode": {
+          "oneof": ["resume", "select"]
+        }
+      },
+      "fields": {
+        "resume": {
+          "type": "DeviceSessionResume",
+          "id": 1
+        },
+        "select": {
+          "type": "DeviceSessionSelect",
+          "id": 2
+        }
+      }
+    },
     "DeviceSession": {
       "fields": {
         "session_id": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport",
-  "version": "1.2.0-alpha.20",
+  "version": "1.2.0-alpha.22",
   "description": "Transport layer abstractions and utilities for OneKey hardware SDK.",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -28,5 +28,5 @@
     "long": "^4.0.0",
     "protobufjs": "^6.11.2"
   },
-  "gitHead": "5fbc1ada90fd3cfda7e5ef08be368cb452018733"
+  "gitHead": "ce94a5ebbe141b0c15db7c68d08085ca1ddb0166"
 }

package/scripts/protobuf-types.js

@@ -69,6 +69,9 @@ const ENUM_KEYS = [
   'ProtocolV2Capability',
 ];
 
+// Safety checks are accepted as both protobuf enum names and numeric legacy values.
+const ENUM_KEYS_WITH_NUMERIC_VALUES = ['SafetyCheckLevel'];
+
 const parseEnumTypescript = (itemName, item) => {
   const value = [];
   const IS_KEY = ENUM_KEYS.includes(itemName);
@@ -87,7 +90,10 @@ const parseEnumTypescript = (itemName, item) => {
   value.push('}');
 
   if (IS_KEY) {
-    value.push(`export type ${itemName} = keyof typeof Enum_${itemName};`);
+    const numericValue = ENUM_KEYS_WITH_NUMERIC_VALUES.includes(itemName)
+      ? ` | Enum_${itemName}`
+      : '';
+    value.push(`export type ${itemName} = keyof typeof Enum_${itemName}${numericValue};`);
   }
   // empty line
   value.push('');

package/src/constants.ts

@@ -48,3 +48,11 @@ export const PROTOCOL_V2_CHANNEL_SOCKET = 2;
 
 /** packet_src for protobuf commands; firmware routes zero to the protobuf dispatcher. */
 export const PROTOCOL_V2_PACKET_SRC_COMMAND = 0;
+
+/**
+ * Shared upper bound for a Protocol V2 request without a method-specific timeout.
+ * Interactive and signing calls may wait on the device UI, so keep this longer than
+ * ordinary transport timeouts while still preventing a stalled link from blocking
+ * the per-device queue forever.
+ */
+export const PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS = 5 * 60 * 1000;

package/src/protocols/index.ts

@@ -9,7 +9,7 @@ import { decode as decodeProtobuf } from '../serialization/protobuf/decode';
 import {
   decodeFrame as decodeV2Frame,
   encodeProtobufFrame,
-  getAckSequence,
+  inspectFrameHeader,
   isAckFrame,
 } from './v2';
 
@@ -76,16 +76,19 @@ export const ProtocolV1 = {
 
 export const ProtocolV2 = {
   isAckFrame,
-  getAckSequence,
+  inspectFrameHeader,
 
   inspectFrame(schemas: ProtocolV2Schemas, frame: Uint8Array) {
-    const { messageTypeId, pbPayload, seq } = decodeV2Frame(frame);
+    const { messageTypeId, pbPayload, seq, router, packetSrc, dataType } = decodeV2Frame(frame);
     const { messageName } = createProtocolV2MessageFromType(messageTypeId, schemas);
     return {
       messageName,
       messageTypeId,
       pbPayload,
       seq,
+      router,
+      packetSrc,
+      dataType,
       type: messageName,
     };
   },
@@ -116,7 +119,18 @@ export const ProtocolV2 = {
     const { messageTypeId, pbPayload, seq, messageName } = this.inspectFrame(schemas, frame);
     const { Message } = createProtocolV2MessageFromType(messageTypeId, schemas);
     const rxByteBuffer = ByteBuffer.wrap(Buffer.from(pbPayload) as unknown as ArrayBuffer);
-    const message = decodeProtobuf(Message, rxByteBuffer);
+    let message: ReturnType<typeof decodeProtobuf>;
+    try {
+      message = decodeProtobuf(Message, rxByteBuffer);
+    } catch (cause) {
+      const error = new Error(
+        `Protocol V2 protobuf decode failed for "${messageName}" ` +
+          `(${messageTypeId}, ${pbPayload.length}-byte payload); ` +
+          'the payload is malformed or incompatible with the active SDK schema.'
+      );
+      (error as Error & { cause?: unknown }).cause = cause;
+      throw error;
+    }
 
     return {
       message,

package/src/protocols/v2/decode.ts

@@ -1,4 +1,9 @@
-import { PROTO_DATA_TYPE_ACK, PROTO_HEAD_CRC_SIZE, PROTO_HEAD_SOF } from './constants';
+import {
+  PROTO_DATA_TYPE_ACK,
+  PROTO_DATA_TYPE_PACKET,
+  PROTO_HEAD_CRC_SIZE,
+  PROTO_HEAD_SOF,
+} from './constants';
 import { crc8 } from './crc8';
 
 export interface ProtoV2Frame {
@@ -8,9 +13,23 @@ export interface ProtoV2Frame {
   pbPayload: Uint8Array;
   /** Sequence number from the frame header */
   seq: number;
+  /** Routing channel from the frame header */
+  router: number;
+  /** Packet source from the frame header */
+  packetSrc: number;
+  /** Packet or ACK discriminator from the frame header */
+  dataType: number;
 }
 
-function validateFrame(data: Uint8Array): number {
+export type ProtoV2FrameHeader = {
+  frameLen: number;
+  router: number;
+  packetSrc: number;
+  dataType: number;
+  seq: number;
+};
+
+export function inspectFrameHeader(data: Uint8Array): ProtoV2FrameHeader {
   if (data.length < PROTO_HEAD_CRC_SIZE) {
     throw new Error(`Protocol V2 frame too short: ${data.length} bytes`);
   }
@@ -23,8 +42,10 @@ function validateFrame(data: Uint8Array): number {
 
   const frameLen = data[1] + data[2] * 256;
 
-  if (data.length < frameLen) {
-    throw new Error(`Frame truncated: expected ${frameLen} bytes, got ${data.length}`);
+  if (data.length !== frameLen) {
+    throw new Error(
+      `Protocol V2 frame length mismatch: expected ${frameLen} bytes, got ${data.length}`
+    );
   }
 
   const expectedHeaderCrc = crc8(data, 3);
@@ -45,7 +66,22 @@ function validateFrame(data: Uint8Array): number {
     );
   }
 
-  return frameLen;
+  // eslint-disable-next-line no-bitwise
+  const dataType = data[5] & 0x03;
+  // eslint-disable-next-line no-bitwise
+  const packetSrc = (data[5] >> 2) & 0x0f;
+  const seq = data[6];
+  if (seq === 0) {
+    throw new Error('Invalid Protocol V2 sequence: 0 is reserved');
+  }
+
+  return {
+    frameLen,
+    router: data[4],
+    packetSrc,
+    dataType,
+    seq,
+  };
 }
 
 export function isAckFrame(data: Uint8Array): boolean {
@@ -54,20 +90,13 @@ export function isAckFrame(data: Uint8Array): boolean {
     return false;
   }
 
-  const frameLen = validateFrame(data);
-  if (frameLen !== PROTO_HEAD_CRC_SIZE) {
-    throw new Error(`Invalid Protocol V2 ACK frame length: ${frameLen}`);
+  const header = inspectFrameHeader(data);
+  if (header.frameLen !== PROTO_HEAD_CRC_SIZE) {
+    throw new Error(`Invalid Protocol V2 ACK frame length: ${header.frameLen}`);
   }
   return true;
 }
 
-export function getAckSequence(data: Uint8Array): number | undefined {
-  if (!isAckFrame(data)) {
-    return undefined;
-  }
-  return data[6];
-}
-
 /**
  * Parse and validate a Protocol V2 response frame.
  *
@@ -79,9 +108,10 @@ export function getAckSequence(data: Uint8Array): number | undefined {
  * Returns the decoded messageTypeId, raw protobuf payload, and sequence number.
  */
 export function decodeFrame(data: Uint8Array): ProtoV2Frame {
-  const frameLen = validateFrame(data);
-
-  const seq = data[6];
+  const { frameLen, router, packetSrc, dataType, seq } = inspectFrameHeader(data);
+  if (dataType !== PROTO_DATA_TYPE_PACKET) {
+    throw new Error(`Invalid Protocol V2 data type: expected packet, got ${dataType}`);
+  }
   // Payload spans bytes 7 to frameLen-2 (inclusive), excluding final CRC byte
   const payloadData = data.slice(7, frameLen - 1);
 
@@ -92,5 +122,5 @@ export function decodeFrame(data: Uint8Array): ProtoV2Frame {
   const messageTypeId = payloadData[0] + payloadData[1] * 256;
   const pbPayload = payloadData.slice(2);
 
-  return { messageTypeId, pbPayload, seq };
+  return { messageTypeId, pbPayload, seq, router, packetSrc, dataType };
 }

package/src/protocols/v2/errors.ts

@@ -0,0 +1,23 @@
+export type ProtocolV2LinkErrorCode =
+  | 'response-timeout'
+  | 'router'
+  | 'packet-source'
+  | 'ack-sequence'
+  | 'response-sequence'
+  | 'frame';
+
+export class ProtocolV2LinkError extends Error {
+  readonly code: ProtocolV2LinkErrorCode;
+
+  readonly cause?: unknown;
+
+  constructor(code: ProtocolV2LinkErrorCode, message: string, cause?: unknown) {
+    super(message);
+    this.name = 'ProtocolV2LinkError';
+    this.code = code;
+    this.cause = cause;
+  }
+}
+
+export const isProtocolV2LinkError = (error: unknown): error is ProtocolV2LinkError =>
+  error instanceof ProtocolV2LinkError;

package/src/protocols/v2/frame-assembler.ts

@@ -1,6 +1,7 @@
 import { PROTOCOL_V2_FRAME_MAX_BYTES } from '../../constants';
 import { PROTO_HEAD_CRC_SIZE, PROTO_HEAD_SOF, PROTO_PRE_HEAD_SIZE } from './constants';
 import { crc8 } from './crc8';
+import { ProtocolV2LinkError } from './errors';
 
 export function concatUint8Arrays(arrays: Uint8Array[]): Uint8Array {
   const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
@@ -58,7 +59,7 @@ export class ProtocolV2FrameAssembler {
 
     if (this.buffer[0] !== PROTO_HEAD_SOF) {
       this.reset();
-      throw new Error('Invalid Protocol V2 SOF');
+      throw new ProtocolV2LinkError('frame', 'Invalid Protocol V2 SOF');
     }
 
     const expectedLen = this.buffer[1] + this.buffer[2] * 256;
@@ -67,11 +68,11 @@ export class ProtocolV2FrameAssembler {
       // complete frame: without resetting, this poison prefix would stay in
       // the buffer forever and deadlock the caller's drain loop.
       this.reset();
-      throw new Error(`Protocol V2 frame length too small: ${expectedLen}`);
+      throw new ProtocolV2LinkError('frame', `Protocol V2 frame length too small: ${expectedLen}`);
     }
     if (expectedLen > this.maxFrameBytes) {
       this.reset();
-      throw new Error(`Protocol V2 frame too large: ${expectedLen}`);
+      throw new ProtocolV2LinkError('frame', `Protocol V2 frame too large: ${expectedLen}`);
     }
 
     if (this.buffer.length < PROTO_PRE_HEAD_SIZE) return undefined;
@@ -82,7 +83,8 @@ export class ProtocolV2FrameAssembler {
     const expectedHeaderCrc = crc8(this.buffer, 3);
     if (this.buffer[3] !== expectedHeaderCrc) {
       this.reset();
-      throw new Error(
+      throw new ProtocolV2LinkError(
+        'frame',
         `Protocol V2 header CRC mismatch: expected 0x${expectedHeaderCrc
           .toString(16)
           .padStart(2, '0')}`

package/src/protocols/v2/index.ts

@@ -2,4 +2,5 @@ export * from './constants';
 export * from './crc8';
 export * from './encode';
 export * from './decode';
+export * from './errors';
 export * from './frame-assembler';

package/src/protocols/v2/link-manager.ts

@@ -17,7 +17,6 @@ export interface ProtocolV2LinkAdapter {
   logger?: ProtocolV2SessionOptions['logger'];
   logPrefix?: string;
   createTimeoutError?: ProtocolV2SessionOptions['createTimeoutError'];
-  writeTimeoutMs?: number;
 }
 
 export type ProtocolV2LinkManagerOptions<Key> = {
@@ -129,7 +128,6 @@ export class ProtocolV2LinkManager<Key> {
       logger: adapter.logger,
       logPrefix: adapter.logPrefix,
       createTimeoutError: adapter.createTimeoutError,
-      writeTimeoutMs: adapter.writeTimeoutMs,
     });
     const link = { adapter, session, state };
     this.links.set(key, link);