@onekeyfe/hd-transport 1.2.8-alpha.111 → 1.2.8-alpha.113

package/dist/utils/transportLog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transportLog.d.ts","sourceRoot":"","sources":["../../src/utils/transportLog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAoF7C,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAKxF;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;EAO9B;AAID,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,MAAM,WAE3D"}
+{"version":3,"file":"transportLog.d.ts","sourceRoot":"","sources":["../../src/utils/transportLog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AA+E7C,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAKxF;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;EAO9B;AAID,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,MAAM,WAE3D"}

package/messages-protocol-v2.json

@@ -11034,61 +11034,6 @@
         }
       }
     },
-    "ZcashSignPczt": {
-      "fields": {
-        "pczt_length": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 1
-        },
-        "pczt_initial_chunk": {
-          "rule": "required",
-          "type": "bytes",
-          "id": 2
-        }
-      }
-    },
-    "ZcashPcztChunkRequest": {
-      "fields": {
-        "chunk_length": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 1
-        }
-      }
-    },
-    "ZcashPcztChunkAck": {
-      "fields": {
-        "data_chunk": {
-          "rule": "required",
-          "type": "bytes",
-          "id": 1
-        }
-      }
-    },
-    "ZcashSignedPczt": {
-      "fields": {
-        "pczt_length": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 1
-        },
-        "pczt_initial_chunk": {
-          "rule": "required",
-          "type": "bytes",
-          "id": 2
-        }
-      }
-    },
-    "ZcashSignedPcztChunkRequest": {
-      "fields": {
-        "chunk_length": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 1
-        }
-      }
-    },
     "wire_in": {
       "type": "bool",
       "id": 50002,
@@ -11514,11 +11459,6 @@
         "MessageType_NeoAddress": 12302,
         "MessageType_NeoSignTx": 12303,
         "MessageType_NeoSignedTx": 12304,
-        "MessageType_ZcashSignPczt": 12402,
-        "MessageType_ZcashSignedPczt": 12403,
-        "MessageType_ZcashPcztChunkRequest": 12404,
-        "MessageType_ZcashPcztChunkAck": 12405,
-        "MessageType_ZcashSignedPcztChunkRequest": 12406,
         "MessageType_DeviceFactoryInfoSet": 60000,
         "MessageType_DeviceFactoryInfoGet": 60001,
         "MessageType_DeviceFactoryInfo": 60002,
@@ -11571,9 +11511,7 @@
         "MessageType_PortfolioUpdate": 61400,
         "MessageType_NftUpdate": 61500,
         "MessageType_OnboardingStatusGet": 61600,
-        "MessageType_OnboardingStatus": 61601,
-        "MessageType_ZcashGetAddress": 12400,
-        "MessageType_ZcashAddress": 12401
+        "MessageType_OnboardingStatus": 61601
       },
       "reserved": [
         [90, 92],
@@ -13792,81 +13730,6 @@
           }
         }
       }
-    },
-    "ZcashAddressType": {
-      "values": {
-        "UNIFIED_ORCHARD_P2PKH": 0,
-        "TRANSPARENT_P2PKH": 1,
-        "UNIFIED_ORCHARD": 2
-      }
-    },
-    "ZcashAddressScope": {
-      "values": {
-        "EXTERNAL": 0,
-        "INTERNAL": 1
-      }
-    },
-    "ZcashGetAddress": {
-      "fields": {
-        "address_n": {
-          "rule": "repeated",
-          "type": "uint32",
-          "id": 1,
-          "options": {
-            "packed": false
-          }
-        },
-        "show_display": {
-          "type": "bool",
-          "id": 2
-        },
-        "include_seed_fingerprint": {
-          "type": "bool",
-          "id": 3
-        },
-        "include_ufvk": {
-          "type": "bool",
-          "id": 4
-        },
-        "diversifier_index": {
-          "type": "uint32",
-          "id": 5,
-          "options": {
-            "default": 0
-          }
-        },
-        "address_type": {
-          "type": "ZcashAddressType",
-          "id": 6,
-          "options": {
-            "default": "UNIFIED_ORCHARD_P2PKH"
-          }
-        },
-        "scope": {
-          "type": "ZcashAddressScope",
-          "id": 7,
-          "options": {
-            "default": "EXTERNAL"
-          }
-        }
-      }
-    },
-    "ZcashAddress": {
-      "fields": {
-        "address": {
-          "rule": "required",
-          "type": "string",
-          "id": 1
-        },
-        "ufvk": {
-          "type": "string",
-          "id": 2
-        },
-        "seed_fingerprint": {
-          "type": "bytes",
-          "id": 3
-        }
-      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport",
-  "version": "1.2.8-alpha.111",
+  "version": "1.2.8-alpha.113",
   "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": "d1e821b961d8060f9cb00d60a23e37c7f6d9206c"
+  "gitHead": "c56caf8fdd87e3a00bdc90aca044e75693704ae3"
 }

package/src/constants.ts

@@ -41,6 +41,13 @@ export const PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE = 900;
 /** Pro2 BLE/UART RX FIFO must hold a complete Proto Link frame. */
 export const PROTOCOL_V2_BLE_FRAME_MAX_BYTES = 2048;
 
+/**
+ * FilesystemFileWrite frames kept in flight by a file write pipeline. The main MCU copies a
+ * complete frame out of its UART FIFO before handling it, but a frame waiting to be parsed and
+ * the next one being received can both be resident: two full frames must fit (4096-byte FIFO).
+ */
+export const PROTOCOL_V2_FILE_WRITE_PIPELINE_WINDOW = 2;
+
 /** @deprecated Use the transport-specific WebUSB or BLE file chunk constant. */
 export const PROTOCOL_V2_FILE_CHUNK_SIZE = PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
 

package/src/index.ts

@@ -37,6 +37,7 @@ export type {
   MessageFromOneKey,
   TransportCallOptions,
   TransportWriteMetrics,
+  ProtocolV2FileWritePipeline,
   LowlevelTransportSharedPlugin,
   LowLevelDevice,
   OneKeyDeviceInfoBase,

package/src/protocols/v2/session.ts

@@ -1,5 +1,6 @@
 import {
   PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS,
+  PROTOCOL_V2_FILE_WRITE_PIPELINE_WINDOW,
   PROTOCOL_V2_PACKET_SRC_COMMAND,
 } from '../../constants';
 import { ProtocolV2FrameAssembler, concatUint8Arrays } from './frame-assembler';
@@ -15,7 +16,11 @@ import * as check from '../../utils/highlevel-checks';
 import { LogBlockCommand } from '../../utils/logBlockCommand';
 
 import type { Root } from 'protobufjs/light';
-import type { MessageFromOneKey, TransportWriteMetrics } from '../../types';
+import type {
+  MessageFromOneKey,
+  ProtocolV2FileWritePipeline,
+  TransportWriteMetrics,
+} from '../../types';
 
 export * from './errors';
 
@@ -62,6 +67,7 @@ export type ProtocolV2CallOptions = {
   returnAfterWrite?: boolean;
   onResponseAfterWrite?: (response: MessageFromOneKey) => void;
   writeWithResponse?: boolean;
+  fileWritePipeline?: ProtocolV2FileWritePipeline;
 };
 
 export { concatUint8Arrays, ProtocolV2FrameAssembler };
@@ -214,6 +220,27 @@ export async function withProtocolTimeout<T>(
   }
 }
 
+function readFileWriteChunk(request: Record<string, unknown>) {
+  const file = request.file as
+    | { path?: unknown; offset?: unknown; total_size?: unknown; data?: { byteLength?: unknown } }
+    | undefined;
+  const offset = Number(file?.offset);
+  const totalSize = Number(file?.total_size);
+  const length = Number(file?.data?.byteLength);
+  if (
+    typeof file?.path !== 'string' ||
+    !Number.isSafeInteger(offset) ||
+    offset < 0 ||
+    !Number.isSafeInteger(totalSize) ||
+    !Number.isSafeInteger(length) ||
+    length <= 0 ||
+    offset + length > totalSize
+  ) {
+    throw new Error('Protocol V2 file write pipeline chunk is invalid');
+  }
+  return { path: file.path, offset, end: offset + length, totalSize };
+}
+
 export class ProtocolV2Session {
   private readonly options: ProtocolV2SessionOptions;
 
@@ -298,6 +325,9 @@ export class ProtocolV2Session {
     data: Record<string, unknown>,
     callOptions: ProtocolV2CallOptions
   ): Promise<MessageFromOneKey> {
+    if (callOptions.fileWritePipeline) {
+      return this.executeFileWritePipeline(name, data, callOptions, callOptions.fileWritePipeline);
+    }
     const {
       schemas,
       router,
@@ -376,68 +406,8 @@ export class ProtocolV2Session {
         const rxFrame = await readFrame(baseCallContext);
         if (abortController.signal.aborted) break;
 
-        let header: ReturnType<typeof ProtocolV2.inspectFrameHeader>;
-        try {
-          header = ProtocolV2.inspectFrameHeader(rxFrame);
-        } catch (cause) {
-          throw new ProtocolV2LinkError(
-            'frame',
-            `Protocol V2 frame validation failed: ${getErrorMessage(cause)}`,
-            cause
-          );
-        }
-        if (header.router !== router) {
-          throw new ProtocolV2LinkError(
-            'router',
-            `Protocol V2 router mismatch: expected ${router}, got ${header.router}`
-          );
-        }
-        if (header.packetSrc !== packetSrc) {
-          throw new ProtocolV2LinkError(
-            'packet-source',
-            `Protocol V2 packet source mismatch: expected ${packetSrc}, got ${header.packetSrc}`
-          );
-        }
-
-        let isAck: boolean;
-        try {
-          isAck = ProtocolV2.isAckFrame(rxFrame);
-        } catch (cause) {
-          throw new ProtocolV2LinkError(
-            'frame',
-            `Protocol V2 ACK validation failed: ${getErrorMessage(cause)}`,
-            cause
-          );
-        }
-        if (isAck) {
-          if (header.seq !== protoSeq) {
-            throw new ProtocolV2LinkError(
-              'ack-sequence',
-              `Protocol V2 ACK sequence mismatch: expected ${protoSeq}, got ${header.seq}`
-            );
-          }
-        } else {
-          let decoded: ReturnType<typeof ProtocolV2.decodeFrame>;
-          try {
-            decoded = ProtocolV2.decodeFrame(schemas, rxFrame);
-          } catch (cause) {
-            throw new ProtocolV2LinkError(
-              'frame',
-              `Protocol V2 frame decode failed: ${getErrorMessage(cause)}`,
-              cause
-            );
-          }
-          // Firmware owns one TX sequence across all channels and packet sources,
-          // so frames routed elsewhere create valid gaps in this session.
-          if (this.lastResponseSequence === decoded.seq) {
-            throw new ProtocolV2LinkError(
-              'response-sequence',
-              `Protocol V2 duplicate response sequence: ${decoded.seq}`
-            );
-          }
-          this.lastResponseSequence = decoded.seq;
-
-          const response = check.call(decoded);
+        const response = this.parseResponseFrame(rxFrame, [protoSeq]);
+        if (response) {
           const { pendingResponseAfterWrite } = this;
           let belongsToWriteOnlyCall = false;
           if (pendingResponseAfterWrite) {
@@ -486,6 +456,273 @@ export class ProtocolV2Session {
       }
     );
   }
+
+  /**
+   * Validates one received frame for this session. Returns undefined for an ACK of one of
+   * `ackSequences`, otherwise the decoded response.
+   */
+  private parseResponseFrame(
+    rxFrame: Uint8Array,
+    ackSequences: readonly number[]
+  ): MessageFromOneKey | undefined {
+    const { schemas, router, packetSrc = PROTOCOL_V2_PACKET_SRC_COMMAND } = this.options;
+    let header: ReturnType<typeof ProtocolV2.inspectFrameHeader>;
+    try {
+      header = ProtocolV2.inspectFrameHeader(rxFrame);
+    } catch (cause) {
+      throw new ProtocolV2LinkError(
+        'frame',
+        `Protocol V2 frame validation failed: ${getErrorMessage(cause)}`,
+        cause
+      );
+    }
+    if (header.router !== router) {
+      throw new ProtocolV2LinkError(
+        'router',
+        `Protocol V2 router mismatch: expected ${router}, got ${header.router}`
+      );
+    }
+    if (header.packetSrc !== packetSrc) {
+      throw new ProtocolV2LinkError(
+        'packet-source',
+        `Protocol V2 packet source mismatch: expected ${packetSrc}, got ${header.packetSrc}`
+      );
+    }
+
+    let isAck: boolean;
+    try {
+      isAck = ProtocolV2.isAckFrame(rxFrame);
+    } catch (cause) {
+      throw new ProtocolV2LinkError(
+        'frame',
+        `Protocol V2 ACK validation failed: ${getErrorMessage(cause)}`,
+        cause
+      );
+    }
+    if (isAck) {
+      if (!ackSequences.includes(header.seq)) {
+        throw new ProtocolV2LinkError(
+          'ack-sequence',
+          `Protocol V2 ACK sequence mismatch: expected ${ackSequences.join('|')}, got ${header.seq}`
+        );
+      }
+      return undefined;
+    }
+
+    let decoded: ReturnType<typeof ProtocolV2.decodeFrame>;
+    try {
+      decoded = ProtocolV2.decodeFrame(schemas, rxFrame);
+    } catch (cause) {
+      throw new ProtocolV2LinkError(
+        'frame',
+        `Protocol V2 frame decode failed: ${getErrorMessage(cause)}`,
+        cause
+      );
+    }
+    // Firmware owns one TX sequence across all channels and packet sources,
+    // so frames routed elsewhere create valid gaps in this session.
+    if (this.lastResponseSequence === decoded.seq) {
+      throw new ProtocolV2LinkError(
+        'response-sequence',
+        `Protocol V2 duplicate response sequence: ${decoded.seq}`
+      );
+    }
+    this.lastResponseSequence = decoded.seq;
+    return check.call(decoded);
+  }
+
+  /**
+   * Writes one file as ordered FilesystemFileWrite chunks while keeping up to
+   * PROTOCOL_V2_FILE_WRITE_PIPELINE_WINDOW chunks in flight. Firmware still processes and
+   * answers every chunk in order, so responses are matched to chunks by position. Upstream
+   * bootloaders append at their own cursor without checking the request offset, so the echoed
+   * offset is what exposes a lost chunk. A device Failure, or `next` returning undefined, stops
+   * sending; the remaining in-flight responses are drained so the link stays usable. The call
+   * then returns the Failure like a serial call, or the last confirmation, which the caller
+   * checks for completeness.
+   */
+  private async executeFileWritePipeline(
+    name: string,
+    data: Record<string, unknown>,
+    callOptions: ProtocolV2CallOptions,
+    pipeline: ProtocolV2FileWritePipeline
+  ): Promise<MessageFromOneKey> {
+    if (name !== 'FilesystemFileWrite') {
+      throw new Error(`Protocol V2 file write pipeline does not support ${name}`);
+    }
+    if (this.pendingResponseAfterWrite) {
+      throw new Error('Protocol V2 file write pipeline cannot start while a response is pending');
+    }
+    const {
+      schemas,
+      router,
+      packetSrc = PROTOCOL_V2_PACKET_SRC_COMMAND,
+      maxFrameBytes,
+      prepareCall,
+      writeFrame,
+      readFrame,
+      logger,
+      logPrefix = 'ProtocolV2',
+      createTimeoutError,
+      generation = 0,
+    } = this.options;
+    const timeoutMs =
+      callOptions.timeoutMs && callOptions.timeoutMs > 0
+        ? callOptions.timeoutMs
+        : PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS;
+    const abortController = new AbortController();
+    const context: ProtocolV2CallContext = {
+      messageName: name,
+      timeoutMs,
+      highThroughput: true,
+      ...(callOptions.writeWithResponse === undefined
+        ? {}
+        : { writeWithResponse: callOptions.writeWithResponse }),
+      generation,
+      signal: abortController.signal,
+    };
+    // One file can take far longer than one chunk, so the watchdog bounds each step instead.
+    const withStepTimeout = <T>(promise: Promise<T>, stepTimeoutMs = timeoutMs) =>
+      withProtocolTimeout(
+        promise,
+        stepTimeoutMs,
+        () =>
+          createTimeoutError
+            ? createTimeoutError(name, timeoutMs)
+            : new Error(`Protocol V2 response timeout after ${timeoutMs}ms for ${name}`),
+        () => {
+          abortController.abort();
+        }
+      );
+    // ACKs and skipped frames must not extend the wait for an in-flight chunk's response.
+    let progressDeadline = 0;
+    const markProgress = () => {
+      progressDeadline = Date.now() + timeoutMs;
+    };
+
+    const inFlight: Array<{ seq: number; path: string; offset: number; end: number }> = [];
+    let firstRequest: Record<string, unknown> | undefined = data;
+    let path: string | undefined;
+    let totalSize: number | undefined;
+    let nextOffset: number | undefined;
+    let sourceDone = false;
+    let failure: MessageFromOneKey | undefined;
+    let lastConfirmed: MessageFromOneKey | undefined;
+
+    const sendNextChunk = async () => {
+      const request = firstRequest ?? (await pipeline.next());
+      firstRequest = undefined;
+      if (!request) {
+        sourceDone = true;
+        return;
+      }
+      const chunk = readFileWriteChunk(request);
+      if (
+        (path !== undefined && chunk.path !== path) ||
+        (totalSize !== undefined && chunk.totalSize !== totalSize) ||
+        (nextOffset !== undefined && chunk.offset !== nextOffset)
+      ) {
+        throw new Error(
+          `Protocol V2 file write pipeline chunk out of order: expected offset ${String(
+            nextOffset
+          )}, got ${chunk.offset}`
+        );
+      }
+      path = chunk.path;
+      totalSize = chunk.totalSize;
+      nextOffset = chunk.end;
+
+      const seq = this.sequenceCursor.next();
+      const frame = ProtocolV2.encodeFrame(schemas, name, request, {
+        packetSrc,
+        router,
+        seq,
+      });
+      if (maxFrameBytes !== undefined && frame.length > maxFrameBytes) {
+        throw new Error(
+          `Protocol V2 frame too large for transport: ${frame.length} > ${maxFrameBytes}`
+        );
+      }
+      const writeStartedAt = Date.now();
+      await withStepTimeout(this.serializeWrite(() => writeFrame(frame, context)));
+      inFlight.push({ seq, path: chunk.path, offset: chunk.offset, end: chunk.end });
+      markProgress();
+      try {
+        callOptions.onWriteCompleted?.({
+          elapsedMs: Math.max(Date.now() - writeStartedAt, 0),
+          frameBytes: frame.byteLength,
+        });
+      } catch (error) {
+        logger?.error?.(`${logPrefix} write metrics callback failed: ${String(error)}`);
+      }
+    };
+
+    await withStepTimeout(Promise.resolve().then(() => prepareCall?.(context)));
+    while (!sourceDone && inFlight.length < PROTOCOL_V2_FILE_WRITE_PIPELINE_WINDOW) {
+      await sendNextChunk();
+    }
+
+    while (inFlight.length > 0) {
+      const rxFrame = await withStepTimeout(
+        readFrame(context),
+        Math.max(progressDeadline - Date.now(), 1)
+      );
+      const response = this.parseResponseFrame(
+        rxFrame,
+        inFlight.map(item => item.seq)
+      );
+      if (!response) {
+        // ACK of an in-flight chunk; its FilesystemFile response follows.
+      } else if (response.type === 'FilesystemFile') {
+        const [expected] = inFlight;
+        const { message } = response;
+        if (
+          Number(message.processed_byte) !== expected.end ||
+          message.path !== expected.path ||
+          Number(message.offset) !== expected.offset ||
+          Number(message.total_size) !== totalSize
+        ) {
+          throw new ProtocolV2LinkError(
+            'frame',
+            `Protocol V2 file write response does not match chunk ${expected.offset}-${
+              expected.end
+            }: got offset ${String(message.offset)} processed_byte ${String(
+              message.processed_byte
+            )}`
+          );
+        }
+        inFlight.shift();
+        markProgress();
+        if (!failure) {
+          lastConfirmed = response;
+          pipeline.onResponse(response);
+          if (!sourceDone) {
+            await sendNextChunk();
+          }
+        }
+      } else if (response.type === 'Failure') {
+        inFlight.shift();
+        markProgress();
+        failure = failure ?? response;
+        sourceDone = true;
+      } else if (COMMON_TERMINAL_RESPONSE_TYPES.has(response.type)) {
+        throw new ProtocolV2LinkError(
+          'frame',
+          `Protocol V2 file write pipeline received unexpected ${response.type}`
+        );
+      } else {
+        logger?.debug?.(
+          `[${logPrefix}] skip unexpected response for ${name}: expected=FilesystemFile got=${response.type}`
+        );
+      }
+    }
+
+    const terminal = failure ?? lastConfirmed;
+    if (!terminal) {
+      throw new ProtocolV2LinkError('frame', 'Protocol V2 file write pipeline ended unconfirmed');
+    }
+    return terminal;
+  }
 }
 
 export async function probeProtocolV2({