@onekeyfe/hd-transport 1.2.0-alpha.99 → 1.2.0

package/messages-protocol-v2.json

@@ -446,6 +446,9 @@
         "MessageType_DeviceCertificateSignature": 60423,
         "MessageType_DeviceCertificateSign": 60424,
         "MessageType_DeviceMiscUsbMscControl": 60440,
+        "MessageType_DeviceFindMyTokenState": 60450,
+        "MessageType_DeviceFindMyTokenUpdate": 60451,
+        "MessageType_DeviceFindMyTokenStateGet": 60452,
         "MessageType_DeviceInfoGet": 60600,
         "MessageType_DeviceInfo": 60601,
         "MessageType_DeviceStatusGet": 60602,
@@ -462,9 +465,10 @@
         "MessageType_FilesystemDirMake": 60809,
         "MessageType_FilesystemDirRemove": 60810,
         "MessageType_FilesystemFormat": 60811,
-        "MessageType_DeviceFirmwareUpdateRequest": 61000,
-        "MessageType_DeviceFirmwareUpdateStatusGet": 61001,
-        "MessageType_DeviceFirmwareUpdateStatus": 61002,
+        "MessageType_DeviceFirmwareUpdateStage": 61000,
+        "MessageType_DeviceFirmwareUpdateRequest": 61001,
+        "MessageType_DeviceFirmwareUpdateStatusGet": 61002,
+        "MessageType_DeviceFirmwareUpdateStatus": 61003,
         "MessageType_DeviceSessionGet": 61200,
         "MessageType_DeviceSession": 61201,
         "MessageType_DeviceSessionAskPin": 61202,
@@ -5403,6 +5407,10 @@
         "request_id": {
           "type": "bytes",
           "id": 5
+        },
+        "source_fingerprint": {
+          "type": "uint32",
+          "id": 6
         }
       }
     },
@@ -5538,6 +5546,14 @@
         "tx_type": {
           "type": "uint32",
           "id": 10
+        },
+        "expected_address": {
+          "type": "bytes",
+          "id": 12
+        },
+        "source_fingerprint": {
+          "type": "uint32",
+          "id": 13
         }
       }
     },
@@ -5618,6 +5634,14 @@
           "rule": "repeated",
           "type": "EthereumAccessListOneKey",
           "id": 11
+        },
+        "expected_address": {
+          "type": "bytes",
+          "id": 12
+        },
+        "source_fingerprint": {
+          "type": "uint32",
+          "id": 13
         }
       }
     },
@@ -5794,6 +5818,10 @@
         "chain_id": {
           "type": "uint64",
           "id": 3
+        },
+        "source_fingerprint": {
+          "type": "uint32",
+          "id": 4
         }
       }
     },
@@ -9473,6 +9501,10 @@
           "rule": "required",
           "type": "bytes",
           "id": 2
+        },
+        "source_fingerprint": {
+          "type": "uint32",
+          "id": 3
         }
       }
     },
@@ -9517,6 +9549,10 @@
         "application_domain": {
           "type": "bytes",
           "id": 5
+        },
+        "source_fingerprint": {
+          "type": "uint32",
+          "id": 6
         }
       }
     },
@@ -9534,6 +9570,10 @@
           "rule": "required",
           "type": "bytes",
           "id": 2
+        },
+        "source_fingerprint": {
+          "type": "uint32",
+          "id": 3
         }
       }
     },
@@ -11763,6 +11803,27 @@
         }
       }
     },
+    "DeviceFindMyTokenUpdate": {
+      "fields": {
+        "token": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 1
+        }
+      }
+    },
+    "DeviceFindMyTokenStateGet": {
+      "fields": {}
+    },
+    "DeviceFindMyTokenState": {
+      "fields": {
+        "burned": {
+          "rule": "required",
+          "type": "bool",
+          "id": 1
+        }
+      }
+    },
     "DeviceFactoryAck": {
       "values": {
         "FACTORY_ACK_SUCCESS": 0,
@@ -11813,14 +11874,14 @@
           "type": "string",
           "id": 2
         },
-        "burn_in_completed": {
-          "type": "bool",
-          "id": 3
-        },
         "factory_test_completed": {
           "type": "bool",
           "id": 4
         },
+        "factory_burn_in_completed": {
+          "type": "bool",
+          "id": 3
+        },
         "manufacture_time": {
           "type": "DeviceFactoryInfoManufactureTime",
           "id": 5
@@ -11892,6 +11953,13 @@
         "FW_MGMT_UPDATER_TASK_STATUS_FAILED_ENTRY_OUT_OF_BOUNDS": 10
       }
     },
+    "DeviceFirmwareUpdatePhase": {
+      "values": {
+        "FW_MGMT_UPDATER_PHASE_PREPARE": 0,
+        "FW_MGMT_UPDATER_PHASE_INSTALL": 1,
+        "FW_MGMT_UPDATER_PHASE_VERIFY": 2
+      }
+    },
     "DeviceFirmwareTarget": {
       "fields": {
         "target_id": {
@@ -11906,7 +11974,7 @@
         }
       }
     },
-    "DeviceFirmwareUpdateRequest": {
+    "DeviceFirmwareUpdateStage": {
       "fields": {
         "targets": {
           "rule": "repeated",
@@ -11915,6 +11983,28 @@
         }
       }
     },
+    "DeviceFirmwareUpdateRequest": {
+      "fields": {
+        "reboot_after_update": {
+          "type": "bool",
+          "id": 1
+        }
+      }
+    },
+    "DeviceFirmwareUpdatePhaseInfo": {
+      "fields": {
+        "phase": {
+          "rule": "required",
+          "type": "DeviceFirmwareUpdatePhase",
+          "id": 1
+        },
+        "progress_percent": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 2
+        }
+      }
+    },
     "DeviceFirmwareUpdateRecord": {
       "fields": {
         "target_id": {
@@ -11926,6 +12016,14 @@
           "type": "DeviceFirmwareUpdateTaskStatus",
           "id": 10
         },
+        "progress_percent": {
+          "type": "uint32",
+          "id": 11
+        },
+        "phase_info": {
+          "type": "DeviceFirmwareUpdatePhaseInfo",
+          "id": 12
+        },
         "payload_version": {
           "type": "uint32",
           "id": 20
@@ -11942,6 +12040,14 @@
           "type": "bool",
           "id": 10
         },
+        "progress_percent": {
+          "type": "bool",
+          "id": 11
+        },
+        "phase_info": {
+          "type": "bool",
+          "id": 12
+        },
         "payload_version": {
           "type": "bool",
           "id": 20
@@ -12096,7 +12202,7 @@
           "type": "bool",
           "id": 100
         },
-        "fw": {
+        "main_mcu": {
           "type": "bool",
           "id": 200
         },
@@ -12165,7 +12271,7 @@
           "type": "DeviceHardwareInfo",
           "id": 100
         },
-        "fw": {
+        "main_mcu": {
           "type": "DeviceMainMcuInfo",
           "id": 200
         },
@@ -12703,9 +12809,16 @@
           "id": 1
         },
         "text": {
-          "rule": "required",
           "type": "string",
           "id": 2
+        },
+        "text_id": {
+          "type": "uint32",
+          "id": 3
+        },
+        "text_arg": {
+          "type": "string",
+          "id": 4
         }
       }
     },
@@ -12736,7 +12849,6 @@
     "ViewSignPage": {
       "fields": {
         "title": {
-          "rule": "required",
           "type": "string",
           "id": 1
         },
@@ -12770,13 +12882,20 @@
           "options": {
             "default": "LayoutDefault"
           }
+        },
+        "title_id": {
+          "type": "uint32",
+          "id": 8
+        },
+        "title_arg": {
+          "type": "string",
+          "id": 9
         }
       }
     },
     "ViewVerifyPage": {
       "fields": {
         "title": {
-          "rule": "required",
           "type": "string",
           "id": 1
         },
@@ -12801,6 +12920,14 @@
         "value_key": {
           "type": "uint32",
           "id": 6
+        },
+        "title_id": {
+          "type": "uint32",
+          "id": 7
+        },
+        "chain_id": {
+          "type": "uint32",
+          "id": 8
         }
       }
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport",
-  "version": "1.2.0-alpha.99",
+  "version": "1.2.0",
   "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": "8924c0e509f84675a2c33c0062166967f5bcb2d0"
+  "gitHead": "cc51df0a415bead21304ad1d8bc92b5312c91344"
 }

package/src/protocols/index.ts

@@ -1,4 +1,5 @@
 import ByteBuffer from 'bytebuffer';
+import { Reader, Type } from 'protobufjs/light';
 
 import { encodeEnvelopeMessage, encodeMessageChunks, encodeTransportPackets } from './v1/packets';
 import { decodeFirstChunk } from './v1/decode';
@@ -29,6 +30,85 @@ type ProtocolV2FrameOptions = {
   seq?: number;
 };
 
+const LEGACY_PROTOCOL_V2_PROTOCOL_INFO = Type.fromJSON('LegacyProtocolInfo', {
+  fields: {
+    version: {
+      rule: 'required',
+      type: 'uint32',
+      id: 1,
+    },
+    supported_messages: {
+      rule: 'repeated',
+      type: 'uint32',
+      id: 2,
+      options: {
+        packed: false,
+      },
+    },
+    protobuf_definition: {
+      type: 'string',
+      id: 3,
+    },
+  },
+});
+
+const decodeLegacyProtocolV2ProtocolInfo = (pbPayload: Uint8Array) => {
+  const byteBuffer = ByteBuffer.wrap(Buffer.from(pbPayload) as unknown as ArrayBuffer);
+  const legacy = decodeProtobuf(LEGACY_PROTOCOL_V2_PROTOCOL_INFO, byteBuffer);
+
+  return {
+    version: legacy.version,
+    build_fingerprint: '',
+    supported_messages: legacy.supported_messages ?? [],
+    // Presence of this legacy field lets Core keep the fallback recovery-only.
+    protobuf_definition: null,
+  };
+};
+
+const isLegacyProtocolV2ProtocolInfoWireLayout = (pbPayload: Uint8Array) => {
+  const reader = Reader.create(pbPayload);
+  let hasVersion = false;
+  try {
+    while (reader.pos < reader.len) {
+      const tag = reader.uint32();
+      // eslint-disable-next-line no-bitwise
+      const fieldNumber = tag >>> 3;
+      // eslint-disable-next-line no-bitwise
+      const wireType = tag & 0x07;
+      if (fieldNumber === 1) {
+        if (wireType !== 0) return false;
+        hasVersion = true;
+      } else if (fieldNumber === 2) {
+        // Legacy field 2 is repeated uint32; current field 2 is a string.
+        if (wireType !== 0) return false;
+      } else if (fieldNumber === 3) {
+        // Legacy field 3 is protobuf_definition; current field 3 is uint32.
+        if (wireType !== 2) return false;
+      } else {
+        return false;
+      }
+      reader.skipType(wireType);
+    }
+  } catch {
+    return false;
+  }
+  return hasVersion;
+};
+
+const tryDecodeLegacyProtocolV2ProtocolInfo = (messageName: string, pbPayload: Uint8Array) => {
+  // TEMPORARY COMPATIBILITY: Remove this fallback after all supported Pro2 and Neo
+  // firmware versions return ProtocolInfo with the current build_fingerprint layout.
+  if (messageName !== 'ProtocolInfo' || !isLegacyProtocolV2ProtocolInfoWireLayout(pbPayload)) {
+    return undefined;
+  }
+
+  try {
+    return decodeLegacyProtocolV2ProtocolInfo(pbPayload);
+  } catch {
+    return undefined;
+  }
+};
+
 const resolveProtocolV2EncodeSchema = (name: string, schemas: ProtocolV2Schemas) => {
   try {
     schemas.protocolV2.lookupType(name);
@@ -123,6 +203,17 @@ export const ProtocolV2 = {
     try {
       message = decodeProtobuf(Message, rxByteBuffer);
     } catch (cause) {
+      const legacyProtocolInfo = tryDecodeLegacyProtocolV2ProtocolInfo(messageName, pbPayload);
+      if (legacyProtocolInfo) {
+        return {
+          message: legacyProtocolInfo,
+          messageName,
+          messageTypeId,
+          pbPayload,
+          seq,
+          type: messageName,
+        };
+      }
       const error = new Error(
         `Protocol V2 protobuf decode failed for "${messageName}" ` +
           `(${messageTypeId}, ${pbPayload.length}-byte payload); ` +

package/src/protocols/v2/errors.ts

@@ -23,3 +23,32 @@ export class ProtocolV2LinkError extends Error {
 
 export const isProtocolV2LinkError = (error: unknown): error is ProtocolV2LinkError =>
   error instanceof ProtocolV2LinkError;
+
+export type ProtocolV2LinkDisabledError = Error & {
+  name: 'ProtocolV2LinkDisabledError';
+  failureCode: string | number;
+  firmwareMessage: string;
+};
+
+export const createProtocolV2LinkDisabledError = (
+  failureCode: string | number,
+  firmwareMessage: string
+): ProtocolV2LinkDisabledError =>
+  Object.assign(new Error(firmwareMessage), {
+    name: 'ProtocolV2LinkDisabledError' as const,
+    failureCode,
+    firmwareMessage,
+  });
+
+export const isProtocolV2LinkDisabledError = (
+  error: unknown
+): error is ProtocolV2LinkDisabledError =>
+  error instanceof Error &&
+  error.name === 'ProtocolV2LinkDisabledError' &&
+  'failureCode' in error &&
+  'firmwareMessage' in error;
+
+export const isProtocolV2LinkDisabledFailure = (failureCode: unknown, firmwareMessage: unknown) =>
+  (failureCode === 'Failure_ProcessError' || failureCode === 5) &&
+  typeof firmwareMessage === 'string' &&
+  firmwareMessage.trim().toLowerCase() === 'link disabled';

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

@@ -1,6 +1,7 @@
 import { ProtocolV2SequenceCursor } from './sequence-cursor';
 import { ProtocolV2LinkError } from './errors';
 import { ProtocolV2Session, getErrorMessage } from './session';
+import { PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS } from '../../constants';
 
 import type { MessageFromOneKey, TransportCallOptions } from '../../types';
 import type { ProtocolV2CallContext, ProtocolV2Schemas, ProtocolV2SessionOptions } from './session';
@@ -61,15 +62,45 @@ export class ProtocolV2LinkManager<Key> {
     options?: TransportCallOptions
   ): Promise<MessageFromOneKey> {
     const generation = this.generations.get(key) ?? 0;
+    const previousQueue = this.callQueues.get(key);
+    const timeoutMs =
+      options?.timeoutMs && options.timeoutMs > 0
+        ? options.timeoutMs
+        : PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS;
+    const queuedAt = Date.now();
+    let queueTimeout: ReturnType<typeof setTimeout> | undefined;
+    let queueTimeoutError: Error | undefined;
+    const timeoutWhileQueued = new Promise<never>((_, reject) => {
+      queueTimeout = setTimeout(() => {
+        queueTimeout = undefined;
+        queueTimeoutError = this.createQueuedCallTimeoutError(key, name, timeoutMs);
+        reject(queueTimeoutError);
+      }, timeoutMs);
+    });
     const run = () => {
+      if (queueTimeout) {
+        clearTimeout(queueTimeout);
+        queueTimeout = undefined;
+      }
+      if (queueTimeoutError) {
+        throw queueTimeoutError;
+      }
       this.assertCallGeneration(key, generation);
-      return this.executeCall(key, createAdapter, name, data, options);
+      const remainingTimeoutMs = previousQueue ? timeoutMs - (Date.now() - queuedAt) : timeoutMs;
+      if (remainingTimeoutMs <= 0) {
+        throw this.createQueuedCallTimeoutError(key, name, timeoutMs);
+      }
+      return this.executeCall(key, createAdapter, name, data, {
+        ...options,
+        timeoutMs: remainingTimeoutMs,
+      });
     };
-    const previous = this.callQueues.get(key) ?? Promise.resolve();
-    const result = previous.then(run, run);
-    const queue = result.catch(() => undefined);
+    const previous = previousQueue ?? Promise.resolve();
+    const execution = previous.then(run, run);
+    const result = Promise.race([execution, timeoutWhileQueued]);
+    const queue = execution.catch(() => undefined);
     this.callQueues.set(key, queue);
-    result
+    execution
       .then(
         () => this.clearSettledCallQueue(key, queue),
         () => this.clearSettledCallQueue(key, queue)
@@ -78,6 +109,17 @@ export class ProtocolV2LinkManager<Key> {
     return result;
   }
 
+  sendFlowControl(
+    key: Key,
+    createAdapter: () => ProtocolV2LinkAdapter,
+    name: string,
+    data: Record<string, unknown>
+  ): Promise<MessageFromOneKey> {
+    const generation = this.generations.get(key) ?? 0;
+    this.assertCallGeneration(key, generation);
+    return this.getOrCreateLink(key, createAdapter).session.sendFlowControl(name, data);
+  }
+
   async invalidateLink(key: Key, reason: string): Promise<void> {
     const generation = (this.generations.get(key) ?? 0) + 1;
     this.generations.set(key, generation);
@@ -195,6 +237,16 @@ export class ProtocolV2LinkManager<Key> {
     }
   }
 
+  private createQueuedCallTimeoutError(key: Key, name: string, timeoutMs: number): Error {
+    const adapterTimeoutError = this.links.get(key)?.adapter.createTimeoutError;
+    return adapterTimeoutError
+      ? adapterTimeoutError(name, timeoutMs)
+      : new ProtocolV2LinkError(
+          'response-timeout',
+          `Protocol V2 call timeout after ${timeoutMs}ms while queued for ${name}`
+        );
+  }
+
   private assertCallGeneration(key: Key, generation: number) {
     const currentGeneration = this.generations.get(key) ?? 0;
     if (currentGeneration === generation) return;