@onekeyfe/hd-transport 1.2.8-alpha.12 → 1.2.8-alpha.120

package/__tests__/protocol-v2-file-write-pipeline.test.js

@@ -0,0 +1,478 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+const { ProtocolV2, ProtocolV2LinkManager } = require('../src');
+const { parseConfigure } = require('../src/serialization/protobuf/messages');
+const { ProtocolV2Session } = require('../src/protocols/v2/session');
+const protocolV2 = require('../src/protocols/v2');
+const { PROTOCOL_V2_FILE_WRITE_PIPELINE_WINDOW } = require('../src/constants');
+
+const schemas = {
+  protocolV1: parseConfigure({
+    nested: {
+      Failure: { fields: { code: { type: 'uint32', id: 1 }, message: { type: 'string', id: 2 } } },
+      MessageType: { values: { MessageType_Failure: 3 } },
+    },
+  }),
+  protocolV2: parseConfigure({
+    nested: {
+      Failure: {
+        fields: {
+          code: { type: 'uint32', id: 1 },
+          subcode: { type: 'uint32', id: 2 },
+          message: { type: 'string', id: 3 },
+        },
+      },
+      ButtonRequest: { fields: { code: { type: 'uint32', id: 1 } } },
+      Success: { fields: { message: { type: 'string', id: 1 } } },
+      FilesystemFile: {
+        fields: {
+          path: { type: 'string', id: 1 },
+          offset: { type: 'uint32', id: 2 },
+          total_size: { type: 'uint32', id: 3 },
+          data: { type: 'bytes', id: 4 },
+          processed_byte: { type: 'uint32', id: 6 },
+        },
+      },
+      FilesystemFileWrite: {
+        fields: {
+          file: { type: 'FilesystemFile', id: 1 },
+          overwrite: { type: 'bool', id: 2 },
+          append: { type: 'bool', id: 3 },
+        },
+      },
+      MessageType: {
+        values: {
+          MessageType_Success: 60207,
+          MessageType_Failure: 60208,
+          MessageType_ButtonRequest: 60209,
+          MessageType_FilesystemFile: 60803,
+          MessageType_FilesystemFileWrite: 60805,
+        },
+      },
+    },
+  }),
+};
+
+const PATH = 'vol0:/application_p1.bin';
+
+const chunk = (offset, length, totalSize) => ({
+  file: { path: PATH, offset, total_size: totalSize, data: new Uint8Array(length) },
+  overwrite: offset === 0,
+  append: false,
+});
+
+const chunksOf = (totalSize, chunkSize) => {
+  const chunks = [];
+  for (let offset = 0; offset < totalSize; offset += chunkSize) {
+    chunks.push(chunk(offset, Math.min(chunkSize, totalSize - offset), totalSize));
+  }
+  return chunks;
+};
+
+const ackFrame = seq => {
+  const ack = new Uint8Array(8);
+  ack[0] = 0x5a;
+  ack[1] = 8;
+  ack[4] = 1;
+  ack[5] = 1;
+  ack[6] = seq;
+  ack[3] = protocolV2.crc8(ack, 3);
+  ack[7] = protocolV2.crc8(ack, 7);
+  return ack;
+};
+
+/**
+ * Simulates the bootloader: every written FileWrite frame is answered in order. `reply` may
+ * replace or prepend frames for a given request index.
+ */
+const createDevice = ({ reply } = {}) => {
+  let responseSeq = 100;
+  const queue = [];
+  const waiters = [];
+  const requests = [];
+  let maxInFlight = 0;
+  let answered = 0;
+  const push = frame => {
+    const waiter = waiters.shift();
+    if (waiter) waiter(frame);
+    else queue.push(frame);
+  };
+  const encode = (name, message) => {
+    responseSeq += 1;
+    return ProtocolV2.encodeFrame(schemas, name, message, {
+      router: 1,
+      packetSrc: 0,
+      seq: responseSeq,
+    });
+  };
+  const respond = () => {
+    const index = answered;
+    answered += 1;
+    const request = requests[index];
+    const { offset, total_size: totalSize, data } = request.message.file;
+    // Decoded protobuf bytes are hex strings.
+    const length = data.length / 2;
+    const confirmation = encode('FilesystemFile', {
+      path: PATH,
+      offset,
+      total_size: totalSize,
+      processed_byte: Number(offset) + length,
+    });
+    const frames = reply ? reply({ index, request, confirmation, encode }) : [confirmation];
+    frames.forEach(push);
+  };
+  return {
+    requests,
+    get maxInFlight() {
+      return maxInFlight;
+    },
+    writeFrame: jest.fn(frame => {
+      const decoded = ProtocolV2.decodeFrame(schemas, frame);
+      requests.push({ seq: frame[6], message: decoded.message });
+      maxInFlight = Math.max(maxInFlight, requests.length - answered);
+      return Promise.resolve();
+    }),
+    inject: (name, message) => push(encode(name, message)),
+    readFrame: jest.fn(() => {
+      while (!queue.length && answered < requests.length) {
+        respond();
+      }
+      const frame = queue.shift();
+      if (frame) return Promise.resolve(frame);
+      return new Promise(resolve => {
+        waiters.push(resolve);
+      });
+    }),
+  };
+};
+
+const createSession = (device, options = {}) =>
+  new ProtocolV2Session({
+    schemas,
+    router: 1,
+    writeFrame: device.writeFrame,
+    readFrame: device.readFrame,
+    ...options,
+  });
+
+const runPipeline = (session, chunks, callOptions = {}, onResponse = jest.fn()) => {
+  const [first, ...rest] = chunks;
+  const next = jest.fn(() => Promise.resolve(rest.shift()));
+  return {
+    next,
+    onResponse,
+    result: session.call('FilesystemFileWrite', first, {
+      ...callOptions,
+      fileWritePipeline: { next, onResponse },
+    }),
+  };
+};
+
+const runManagedPipeline = (device, chunks) => {
+  const adapter = {
+    router: 1,
+    generation: 1,
+    prepareCall: jest.fn(),
+    writeFrame: device.writeFrame,
+    readFrame: device.readFrame,
+    reset: jest.fn(),
+  };
+  const manager = new ProtocolV2LinkManager({
+    getSchemas: () => schemas,
+    classifyError: () => 'link-fatal',
+  });
+  const [first, ...rest] = chunks;
+  return {
+    adapter,
+    result: manager.call('device-a', () => adapter, 'FilesystemFileWrite', first, {
+      fileWritePipeline: { next: () => Promise.resolve(rest.shift()), onResponse: jest.fn() },
+    }),
+  };
+};
+
+describe('Protocol V2 file write pipeline', () => {
+  test('keeps two ordered chunks in flight and confirms each one', async () => {
+    const device = createDevice();
+    const session = createSession(device);
+    const { result, onResponse } = runPipeline(session, chunksOf(10, 2));
+
+    await expect(result).resolves.toMatchObject({
+      type: 'FilesystemFile',
+      message: { processed_byte: 10 },
+    });
+    expect(PROTOCOL_V2_FILE_WRITE_PIPELINE_WINDOW).toBe(2);
+    expect(device.maxInFlight).toBe(2);
+    expect(device.requests.map(request => request.message.file.offset)).toEqual([0, 2, 4, 6, 8]);
+    expect(onResponse.mock.calls.map(([response]) => response.message.processed_byte)).toEqual([
+      2, 4, 6, 8, 10,
+    ]);
+  });
+
+  test('sends a single-chunk file without asking for more than the source has', async () => {
+    const device = createDevice();
+    const session = createSession(device);
+    const { result, next } = runPipeline(session, chunksOf(3, 4));
+
+    await expect(result).resolves.toMatchObject({ message: { processed_byte: 3 } });
+    expect(device.requests).toHaveLength(1);
+    expect(next).toHaveBeenCalledTimes(1);
+  });
+
+  test('skips an ACK of an in-flight chunk', async () => {
+    const device = createDevice({
+      reply: ({ index, request, confirmation }) =>
+        index === 0 ? [ackFrame(request.seq), confirmation] : [confirmation],
+    });
+    const session = createSession(device);
+    const { result } = runPipeline(session, chunksOf(4, 2));
+
+    await expect(result).resolves.toMatchObject({ message: { processed_byte: 4 } });
+  });
+
+  test('drains in-flight chunks after a device Failure and returns it', async () => {
+    const device = createDevice({
+      reply: ({ index, confirmation, encode }) =>
+        index >= 1
+          ? [encode('Failure', { code: 9, message: 'Write offset mismatch' })]
+          : [confirmation],
+    });
+    const session = createSession(device);
+    const { result, next, onResponse } = runPipeline(session, chunksOf(10, 2));
+
+    await expect(result).resolves.toEqual({
+      type: 'Failure',
+      message: expect.objectContaining({ message: 'Write offset mismatch' }),
+    });
+    // Chunk 0 confirmed, chunk 1 failed; chunk 2 was already in flight and is drained.
+    expect(onResponse).toHaveBeenCalledTimes(1);
+    expect(device.requests).toHaveLength(3);
+    expect(device.readFrame).toHaveBeenCalledTimes(3);
+    expect(next).toHaveBeenCalledTimes(2);
+  });
+
+  test('keeps the link after a device Failure', async () => {
+    const device = createDevice({
+      reply: ({ encode }) => [encode('Failure', { code: 9, message: 'Write offset mismatch' })],
+    });
+    const { adapter, result } = runManagedPipeline(device, chunksOf(6, 2));
+
+    await expect(result).resolves.toMatchObject({ type: 'Failure' });
+    expect(adapter.reset).not.toHaveBeenCalled();
+    expect(adapter.prepareCall).toHaveBeenCalledTimes(1);
+  });
+
+  test('invalidates the link when a confirmation does not match the oldest chunk', async () => {
+    const device = createDevice({
+      reply: ({ index, confirmation, encode }) =>
+        index === 1
+          ? [encode('FilesystemFile', { path: PATH, offset: 4, total_size: 6, processed_byte: 6 })]
+          : [confirmation],
+    });
+    const { adapter, result } = runManagedPipeline(device, chunksOf(6, 2));
+
+    await expect(result).rejects.toEqual(
+      expect.objectContaining({ name: 'ProtocolV2LinkError', code: 'frame' })
+    );
+    expect(adapter.reset).toHaveBeenCalled();
+  });
+
+  test('rejects an interactive response inside the pipeline', async () => {
+    const device = createDevice({
+      reply: ({ encode }) => [encode('ButtonRequest', { code: 1 })],
+    });
+    const session = createSession(device);
+    const { result } = runPipeline(session, chunksOf(4, 2));
+
+    await expect(result).rejects.toEqual(
+      expect.objectContaining({ name: 'ProtocolV2LinkError', code: 'frame' })
+    );
+  });
+
+  test('rejects a source chunk that skips an offset before writing it', async () => {
+    const device = createDevice();
+    const session = createSession(device);
+    const { result } = runPipeline(session, [chunk(0, 2, 8), chunk(4, 2, 8)]);
+
+    await expect(result).rejects.toThrow('chunk out of order: expected offset 2, got 4');
+    await expect(result).rejects.toEqual(
+      expect.objectContaining({ name: 'ProtocolV2LinkError', code: 'frame' })
+    );
+    expect(device.requests).toHaveLength(1);
+  });
+
+  test.each([
+    ['path', { path: 'vol0:/application_p2.bin' }],
+    ['total size', { total_size: 9 }],
+  ])('rejects a source chunk with another %s before writing it', async (_field, file) => {
+    const device = createDevice();
+    const session = createSession(device);
+    const second = chunk(2, 2, 8);
+    const { result } = runPipeline(session, [
+      chunk(0, 2, 8),
+      { ...second, file: { ...second.file, ...file } },
+    ]);
+
+    await expect(result).rejects.toThrow('chunk belongs to a different file');
+    await expect(result).rejects.toEqual(
+      expect.objectContaining({ name: 'ProtocolV2LinkError', code: 'frame' })
+    );
+    expect(device.requests).toHaveLength(1);
+  });
+
+  test.each([
+    ['path', { path: 'vol0:/application_p2.bin' }],
+    ['total size', { total_size: 8 }],
+  ])('invalidates the link when a confirmation echoes another %s', async (_field, echo) => {
+    const device = createDevice({
+      reply: ({ index, confirmation, encode }) =>
+        index === 0
+          ? [
+              encode('FilesystemFile', {
+                path: PATH,
+                offset: 0,
+                total_size: 6,
+                processed_byte: 2,
+                ...echo,
+              }),
+            ]
+          : [confirmation],
+    });
+    const { adapter, result } = runManagedPipeline(device, chunksOf(6, 2));
+
+    await expect(result).rejects.toEqual(
+      expect.objectContaining({ name: 'ProtocolV2LinkError', code: 'frame' })
+    );
+    expect(adapter.reset).toHaveBeenCalled();
+  });
+
+  test.each(['readFrame', 'writeFrame'])(
+    'passes a %s transport error through unchanged with chunks in flight',
+    async method => {
+      const device = createDevice();
+      const linkLost = new Error('BLE device disconnected');
+      const original = device[method].getMockImplementation();
+      let calls = 0;
+      device[method].mockImplementation((...args) => {
+        calls += 1;
+        // The second write, or the first read, happens with chunk 0 still in flight.
+        return calls === (method === 'writeFrame' ? 2 : 1)
+          ? Promise.reject(linkLost)
+          : original(...args);
+      });
+      const session = createSession(device);
+      const { result } = runPipeline(session, chunksOf(6, 2));
+
+      await expect(result).rejects.toBe(linkLost);
+      expect(device.requests.length).toBeGreaterThan(0);
+    }
+  );
+
+  test('drains the in-flight chunk and returns the last confirmation when the source stops', async () => {
+    const device = createDevice();
+    const session = createSession(device);
+    const { result, onResponse } = runPipeline(session, [chunk(0, 2, 6), chunk(2, 2, 6)]);
+
+    await expect(result).resolves.toMatchObject({
+      type: 'FilesystemFile',
+      message: { processed_byte: 4 },
+    });
+    expect(onResponse).toHaveBeenCalledTimes(2);
+  });
+
+  test('detects a lost chunk when the bootloader appends at its own cursor', async () => {
+    let cursor = 0;
+    const device = createDevice({
+      reply: ({ index, request, encode }) => {
+        // The third frame never reaches the bootloader, which echoes the request offset but
+        // reports its own cursor in processed_byte.
+        if (index === 2) return [];
+        const { offset, total_size: totalSize, data } = request.message.file;
+        cursor += data.length / 2;
+        return [
+          encode('FilesystemFile', {
+            path: PATH,
+            offset,
+            total_size: totalSize,
+            processed_byte: cursor,
+          }),
+        ];
+      },
+    });
+    const session = createSession(device);
+    const { result, onResponse } = runPipeline(session, chunksOf(10, 2));
+
+    await expect(result).rejects.toEqual(
+      expect.objectContaining({ name: 'ProtocolV2LinkError', code: 'frame' })
+    );
+    expect(onResponse.mock.calls.map(([response]) => response.message.processed_byte)).toEqual([
+      2, 4,
+    ]);
+  });
+
+  test('does not let skipped frames extend the wait for a response', async () => {
+    const device = createDevice({ reply: () => [] });
+    const noise = setInterval(() => device.inject('Success', { message: 'unrelated' }), 10);
+    try {
+      const session = createSession(device);
+      const { result } = runPipeline(session, chunksOf(2, 2), { timeoutMs: 60 });
+
+      await expect(result).rejects.toThrow('Protocol V2 response timeout after 60ms');
+    } finally {
+      clearInterval(noise);
+    }
+  });
+
+  test('rejects a chunk whose frame exceeds the transport limit', async () => {
+    const device = createDevice();
+    const session = createSession(device, { maxFrameBytes: 64 });
+    const { result } = runPipeline(session, [chunk(0, 128, 128)]);
+
+    await expect(result).rejects.toThrow('Protocol V2 frame too large for transport');
+    await expect(result).rejects.not.toEqual(
+      expect.objectContaining({ name: 'ProtocolV2LinkError' })
+    );
+    expect(device.requests).toHaveLength(0);
+  });
+
+  test('bounds each response wait instead of the whole file', async () => {
+    const device = createDevice();
+    const read = device.readFrame.getMockImplementation();
+    device.readFrame.mockImplementation(
+      () =>
+        new Promise(resolve => {
+          setTimeout(() => resolve(read()), 40);
+        })
+    );
+    const session = createSession(device);
+    const { result } = runPipeline(session, chunksOf(8, 2), { timeoutMs: 100 });
+
+    // Four 40 ms responses outlast the 100 ms timeout, but no single wait does.
+    await expect(result).resolves.toMatchObject({ message: { processed_byte: 8 } });
+  });
+
+  test('times out a stalled response with the transport error', async () => {
+    const device = createDevice();
+    device.readFrame.mockImplementation(() => new Promise(() => {}));
+    const createTimeoutError = jest.fn(
+      (name, timeoutMs) => new Error(`BLE timeout ${name} ${timeoutMs}`)
+    );
+    const session = createSession(device, { createTimeoutError });
+    const { result } = runPipeline(session, chunksOf(4, 2), { timeoutMs: 50 });
+
+    await expect(result).rejects.toThrow('BLE timeout FilesystemFileWrite 50');
+    expect(device.writeFrame.mock.calls[0][1].signal.aborted).toBe(true);
+  });
+
+  test('stops when the caller rejects a confirmed chunk', async () => {
+    const device = createDevice();
+    const session = createSession(device);
+    const { result } = runPipeline(session, chunksOf(10, 2), {}, () => {
+      throw new Error('cancelled');
+    });
+
+    await expect(result).rejects.toThrow('cancelled');
+    await expect(result).rejects.toEqual(
+      expect.objectContaining({ name: 'ProtocolV2LinkError', code: 'frame' })
+    );
+    expect(device.requests).toHaveLength(2);
+  });
+});

package/dist/constants.d.ts

@@ -10,6 +10,7 @@ export declare const PROTOCOL_V2_BLE_FILE_CHUNK_SIZE = 1800;
 export declare const PROTOCOL_V2_BLE_FIRMWARE_FILE_CHUNK_SIZE = 1960;
 export declare const PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE = 900;
 export declare const PROTOCOL_V2_BLE_FRAME_MAX_BYTES = 2048;
+export declare const PROTOCOL_V2_FILE_WRITE_PIPELINE_WINDOW = 2;
 export declare const PROTOCOL_V2_FILE_CHUNK_SIZE = 4000;
 export declare const PROTOCOL_V2_CHANNEL_USB = 0;
 export declare const PROTOCOL_V2_CHANNEL_BLE_UART = 1;

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB,KAAO,CAAC;AAG1C,eAAO,MAAM,uBAAuB,KAAO,CAAC;AAG5C,eAAO,MAAM,8BAA8B,KAAK,CAAC;AAGjD,eAAO,MAAM,2BAA2B,QAAqC,CAAC;AAG9E,eAAO,MAAM,+BAA+B,QAAQ,CAAC;AAGrD,eAAO,MAAM,gCAAgC,QAA0C,CAAC;AAKxF,eAAO,MAAM,2BAA2B,OAAO,CAAC;AAGhD,eAAO,MAAM,kCAAkC,OAAO,CAAC;AAGvD,eAAO,MAAM,+BAA+B,OAAO,CAAC;AAMpD,eAAO,MAAM,wCAAwC,OAAO,CAAC;AAG7D,eAAO,MAAM,oCAAoC,MAAM,CAAC;AAGxD,eAAO,MAAM,+BAA+B,OAAO,CAAC;AAGpD,eAAO,MAAM,2BAA2B,OAAqC,CAAC;AAM9E,eAAO,MAAM,uBAAuB,IAAI,CAAC;AACzC,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAC9C,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAG5C,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAQhD,eAAO,MAAM,uCAAuC,QAAgB,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB,KAAO,CAAC;AAG1C,eAAO,MAAM,uBAAuB,KAAO,CAAC;AAG5C,eAAO,MAAM,8BAA8B,KAAK,CAAC;AAGjD,eAAO,MAAM,2BAA2B,QAAqC,CAAC;AAG9E,eAAO,MAAM,+BAA+B,QAAQ,CAAC;AAGrD,eAAO,MAAM,gCAAgC,QAA0C,CAAC;AAKxF,eAAO,MAAM,2BAA2B,OAAO,CAAC;AAGhD,eAAO,MAAM,kCAAkC,OAAO,CAAC;AAGvD,eAAO,MAAM,+BAA+B,OAAO,CAAC;AAOpD,eAAO,MAAM,wCAAwC,OAAO,CAAC;AAG7D,eAAO,MAAM,oCAAoC,MAAM,CAAC;AAGxD,eAAO,MAAM,+BAA+B,OAAO,CAAC;AAQpD,eAAO,MAAM,sCAAsC,IAAI,CAAC;AAGxD,eAAO,MAAM,2BAA2B,OAAqC,CAAC;AAM9E,eAAO,MAAM,uBAAuB,IAAI,CAAC;AACzC,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAC9C,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAG5C,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAQhD,eAAO,MAAM,uCAAuC,QAAgB,CAAC"}

package/dist/index.d.ts

@@ -323,6 +323,12 @@ type OneKeyDeviceInfoWithSession = OneKeyUsbDeviceInfo & {
 type OneKeyMobileDeviceInfo = {
     id: string;
     name: string | null;
+    /**
+     * Color letter of the serial number ('A'-'Z') from the Pro2 / Neo BLE advertisement,
+     * possibly seen in an earlier scan. Set by the React Native and Electron BLE
+     * transports; absent when unknown.
+     */
+    bleColorCode?: string;
 };
 type OneKeyDeviceInfoBase = {
     commType: OneKeyDeviceCommType;
@@ -353,6 +359,18 @@ type TransportWriteMetrics = {
     elapsedMs: number;
     frameBytes: number;
 };
+/**
+ * Supplies the remaining chunks of one file for an ordered FilesystemFileWrite pipeline.
+ * The call's request data is the first chunk; `next` returns the following chunk in offset
+ * order, or undefined to stop. The call then resolves with the last confirmation (or the
+ * device Failure), so the caller must check `processed_byte` for completeness. Callbacks
+ * should not throw: an error escapes with chunks still in flight and invalidates the link.
+ */
+type ProtocolV2FileWritePipeline = {
+    next: () => Promise<Record<string, unknown> | undefined>;
+    /** Called for each chunk after the device confirms it, in offset order. */
+    onResponse: (response: MessageFromOneKey) => void;
+};
 type TransportCallOptions = {
     timeoutMs?: number;
     expectedTypes?: string[];
@@ -366,6 +384,12 @@ type TransportCallOptions = {
     onResponseAfterWrite?: (response: MessageFromOneKey) => void;
     /** Prefer acknowledged BLE characteristic writes for this call when supported. */
     writeWithResponse?: boolean;
+    /**
+     * Protocol V2 only: keep up to PROTOCOL_V2_FILE_WRITE_PIPELINE_WINDOW ordered
+     * FilesystemFileWrite frames of one file in flight within this call. `timeoutMs`
+     * bounds each frame write and each response instead of the whole file.
+     */
+    fileWritePipeline?: ProtocolV2FileWritePipeline;
 };
 type ITransportInitFn = (logger?: any, emitter?: EventEmitter, plugin?: LowlevelTransportSharedPlugin) => Promise<string>;
 type Transport = {
@@ -6827,6 +6851,7 @@ type ProtocolV2CallOptions = {
     returnAfterWrite?: boolean;
     onResponseAfterWrite?: (response: MessageFromOneKey) => void;
     writeWithResponse?: boolean;
+    fileWritePipeline?: ProtocolV2FileWritePipeline;
 };
 
 declare function hexToBytes(hex: string): Uint8Array;
@@ -6850,7 +6875,24 @@ declare class ProtocolV2Session {
     call(name: string, data: Record<string, unknown>, callOptions?: ProtocolV2CallOptions): Promise<MessageFromOneKey>;
     sendFlowControl(name: string, data: Record<string, unknown>): Promise<MessageFromOneKey>;
     private serializeWrite;
+    private reportWriteCompleted;
+    private createCallTimeoutError;
     private executeCall;
+    private encodeRequestFrame;
+    /**
+     * Validates one received frame for this session. Returns undefined for an ACK of one of
+     * `ackSequences`, otherwise the decoded response.
+     */
+    private parseResponseFrame;
+    /**
+     * 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.
+     */
+    private executeFileWritePipeline;
 }
 declare function probeProtocolV2({ call, timeoutMs, logger, logPrefix, onBeforeProbe, onProbeFailed, shouldRethrow, }: {
     call: (name: string, data: Record<string, unknown>, options?: ProtocolV2CallOptions) => Promise<MessageFromOneKey>;
@@ -6985,14 +7027,22 @@ declare const PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE = 4000;
 /** Generic FilesystemFileWrite chunk size over BLE, including support for long filesystem paths. */
 declare const PROTOCOL_V2_BLE_FILE_CHUNK_SIZE = 1800;
 /**
- * FirmwareUpdateV4 chunk size for its fixed BLE staging paths.
+ * FirmwareUpdateV4 chunk size for its fixed BLE staging paths when writes are serial.
  * The longest current path still leaves 28 bytes below the 2048-byte BLE frame limit.
+ * Pipelined writes use PROTOCOL_V2_BLE_FILE_CHUNK_SIZE so two frames fit the UART FIFO.
  */
 declare const PROTOCOL_V2_BLE_FIRMWARE_FILE_CHUNK_SIZE = 1960;
 /** BLE FilesystemFileRead chunk size, limited by the Pro2 1024-byte UART TX buffer. */
 declare const PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE = 900;
 /** Pro2 BLE/UART RX FIFO must hold a complete Proto Link frame. */
 declare 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).
+ * With 1800-byte chunks two frames take about 3.75 KB.
+ */
+declare const PROTOCOL_V2_FILE_WRITE_PIPELINE_WINDOW = 2;
 /** @deprecated Use the transport-specific WebUSB or BLE file chunk constant. */
 declare const PROTOCOL_V2_FILE_CHUNK_SIZE = 4000;
 /**
@@ -7103,4 +7153,4 @@ declare const _default: {
     withProtocolTimeout: typeof withProtocolTimeout;
 };
 
-export { AcquireInput, Address, AlephiumAddress, AlephiumBytecodeAck, AlephiumBytecodeRequest, AlephiumGetAddress, AlephiumMessageSignature, AlephiumSignMessage, AlephiumSignTx, AlephiumSignedTx, AlephiumTxAck, AlephiumTxRequest, AlgorandAddress, AlgorandGetAddress, AlgorandSignTx, AlgorandSignedTx, AmountUnit, ApplyFlags, ApplySettings, AptosAddress, AptosGetAddress, AptosMessagePayload, AptosMessageSignature, AptosSignMessage, AptosSignSIWAMessage, AptosSignTx, AptosSignedTx, AptosTransactionType, AuthorizeCoinJoin, BIP32Address, BabylonDeriveContextHash, BabylonDerivedContextHash, BackupDevice, BackupType, BatchGetPublickeys, BenfenAddress, BenfenGetAddress, BenfenMessageSignature, BenfenSignMessage, BenfenSignTx, BenfenSignedTx, BenfenTxAck, BenfenTxRequest, BinanceAddress, BinanceCancelMsg, BinanceCoin, BinanceGetAddress, BinanceGetPublicKey, BinanceInputOutput, BinanceOrderMsg, BinanceOrderSide, BinanceOrderType, BinancePublicKey, BinanceSignTx, BinanceSignedTx, BinanceTimeInForce, BinanceTransferMsg, BinanceTxRequest, BixinBackupAck, BixinBackupDevice, BixinBackupDeviceAck, BixinBackupRequest, BixinLoadDevice, BixinMessageSE, BixinOutMessageSE, BixinPinInputOnDevice, BixinRestoreAck, BixinRestoreRequest, BixinSeedOperate, BixinVerifyDeviceAck, BixinVerifyDeviceRequest, BixinWhiteListAck, BixinWhiteListRequest, BlurRequest, ButtonAck, ButtonRequest, ButtonRequestType, Cancel, CancelAuthorization, CanonicalBitcoinNetwork, Capability, CardanoAddress, CardanoAddressParametersType, CardanoAddressType, CardanoAssetGroup, CardanoBlockchainPointerType, CardanoCVoteRegistrationDelegation, CardanoCVoteRegistrationFormat, CardanoCVoteRegistrationParametersType, CardanoCertificateType, CardanoDRep, CardanoDRepType, CardanoDerivationType, CardanoGetAddress, CardanoGetNativeScriptHash, CardanoGetPublicKey, CardanoMessageSignature, CardanoNativeScript, CardanoNativeScriptHash, CardanoNativeScriptHashDisplayFormat, CardanoNativeScriptType, CardanoPoolMetadataType, CardanoPoolOwner, CardanoPoolParametersType, CardanoPoolRelayParameters, CardanoPoolRelayType, CardanoPublicKey, CardanoSignMessage, CardanoSignTxFinished, CardanoSignTxInit, CardanoToken, CardanoTxAuxiliaryData, CardanoTxAuxiliaryDataSupplement, CardanoTxAuxiliaryDataSupplementType, CardanoTxBodyHash, CardanoTxCertificate, CardanoTxCollateralInput, CardanoTxHostAck, CardanoTxInlineDatumChunk, CardanoTxInput, CardanoTxItemAck, CardanoTxMint, CardanoTxOutput, CardanoTxOutputSerializationFormat, CardanoTxReferenceInput, CardanoTxReferenceScriptChunk, CardanoTxRequiredSigner, CardanoTxSigningMode, CardanoTxWithdrawal, CardanoTxWitnessRequest, CardanoTxWitnessResponse, CardanoTxWitnessType, ChangeOutputScriptType, ChangePin, ChangeWipeCode, CipherKeyValue, CipheredKeyValue, CoinJoinRequest, CoinPurchaseMemo, CommandFlags, ConfluxAddress, ConfluxGetAddress, ConfluxMessageSignature, ConfluxSignMessage, ConfluxSignMessageCIP23, ConfluxSignTx, ConfluxTxAck, ConfluxTxRequest, CosmosAddress, CosmosGetAddress, CosmosSignTx, CosmosSignedTx, DecredStakingSpendType, Deprecated_PassphraseStateAck, Deprecated_PassphraseStateRequest, DeviceAnimationAction, DeviceAnimationControl, DeviceBackToBoot, DeviceCertificate, DeviceCertificateRead, DeviceCertificateSign, DeviceCertificateSignature, DeviceCertificateWrite, DeviceCoprocessorInfo, DeviceEraseSector, DeviceErrorCode, DeviceFactoryAck, DeviceFactoryInfo, DeviceFactoryInfoGet, DeviceFactoryInfoManufactureTime, DeviceFactoryInfoSet, DeviceFactoryPermanentLock, DeviceFactoryTest, DeviceFindMyTokenState, DeviceFindMyTokenStateGet, DeviceFindMyTokenUpdate, DeviceFirmwareImageInfo, DeviceFirmwareTarget, DeviceFirmwareTargetType, DeviceFirmwareUpdatePhase, DeviceFirmwareUpdatePhaseInfo, DeviceFirmwareUpdateRecord, DeviceFirmwareUpdateRecordFields, DeviceFirmwareUpdateRequest, DeviceFirmwareUpdateStage, DeviceFirmwareUpdateStatus, DeviceFirmwareUpdateStatusGet, DeviceFirmwareUpdateTaskStatus, DeviceHardwareInfo, DeviceInfo, DeviceInfoGet, DeviceInfoSettings, DeviceInfoTargets, DeviceInfoTypes, DeviceMainMcuInfo, DeviceMiscUsbMscControl, DeviceReboot, DeviceRebootType, DeviceSEInfo, DeviceSEState, DeviceSeType, DeviceSession, DeviceSessionAskPassphrase, DeviceSessionAskPin, DeviceSessionAskPin_FailureSubCodes, DeviceSessionErrorCode, DeviceSessionGet, DeviceSessionPinType, DeviceSessionSeedDomain, DeviceSettings, DeviceSettingsGet, DeviceSettingsPage, DeviceSettingsPageShow, DeviceSettingsSet, DeviceStatus, DeviceStatusGet, DeviceType, DnxAddress, DnxComputedKeyImage, DnxGetAddress, DnxInputAck, DnxInputRequest, DnxRTSigsRequest, DnxSignTx, DnxSignedTx, DnxTxKey, DoPreauthorized, ECDHSessionKey, EcdsaPublicKeys, EmmcDir, EmmcDirList, EmmcDirMake, EmmcDirRemove, EmmcFile, EmmcFileDelete, EmmcFileRead, EmmcFileWrite, EmmcFixPermission, EmmcPath, EmmcPathInfo, EndSession, Entropy, EntropyAck, EntropyRequest, Enum_BackupType, Enum_ButtonRequestType, Enum_CanonicalBitcoinNetwork, Enum_Capability, Enum_InputScriptType, Enum_KaspaInputScriptType, Enum_KaspaOutputScriptType, Enum_KaspaRequestType, Enum_OutputScriptType, Enum_PinMatrixRequestType, Enum_ProtocolV2Capability, Enum_RequestType, Enum_SafetyCheckLevel, Enum_WordRequestType, EosActionBuyRam, EosActionBuyRamBytes, EosActionCommon, EosActionDelegate, EosActionDeleteAuth, EosActionLinkAuth, EosActionNewAccount, EosActionRefund, EosActionSellRam, EosActionTransfer, EosActionUndelegate, EosActionUnknown, EosActionUnlinkAuth, EosActionUpdateAuth, EosActionVoteProducer, EosAsset, EosAuthorization, EosAuthorizationAccount, EosAuthorizationKey, EosAuthorizationWait, EosGetPublicKey, EosPermissionLevel, EosPublicKey, EosSignTx, EosSignedTx, EosTxActionAck, EosTxActionRequest, EosTxHeader, EthereumAccessList, EthereumAccessListOneKey, EthereumAddress, EthereumAddressOneKey, EthereumAuthorizationOneKey, EthereumAuthorizationSignature, EthereumDataType, EthereumDataTypeOneKey, EthereumDefinitionType, EthereumDefinitions, EthereumFieldType, EthereumFieldTypeOneKey, EthereumGetAddress, EthereumGetAddressOneKey, EthereumGetPublicKey, EthereumGetPublicKeyOneKey, EthereumGnosisSafeTxAck, EthereumGnosisSafeTxOperation, EthereumGnosisSafeTxRequest, EthereumMessageSignature, EthereumMessageSignatureOneKey, EthereumNetworkInfo, EthereumPublicKey, EthereumPublicKeyOneKey, EthereumSignMessage, EthereumSignMessageEIP712, EthereumSignMessageOneKey, EthereumSignTx, EthereumSignTxEIP1559, EthereumSignTxEIP1559OneKey, EthereumSignTxEIP7702OneKey, EthereumSignTxOneKey, EthereumSignTypedData, EthereumSignTypedDataOneKey, EthereumSignTypedDataQR, EthereumSignTypedHash, EthereumSignTypedHashOneKey, EthereumStructMember, EthereumStructMemberOneKey, EthereumTokenInfo, EthereumTxAck, EthereumTxAckOneKey, EthereumTxRequest, EthereumTxRequestOneKey, EthereumTypedDataSignature, EthereumTypedDataSignatureOneKey, EthereumTypedDataStructAck, EthereumTypedDataStructAckOneKey, EthereumTypedDataStructRequest, EthereumTypedDataStructRequestOneKey, EthereumTypedDataValueAck, EthereumTypedDataValueAckOneKey, EthereumTypedDataValueRequest, EthereumTypedDataValueRequestOneKey, EthereumVerifyMessage, EthereumVerifyMessageOneKey, ExportType, Failure, FailureType, Features, FileInfo, FileInfoList, FilecoinAddress, FilecoinGetAddress, FilecoinSignTx, FilecoinSignedTx, FilesystemDir, FilesystemDirList, FilesystemDirMake, FilesystemDirRemove, FilesystemFile, FilesystemFileDelete, FilesystemFileRead, FilesystemFileWrite, FilesystemFormat, FilesystemPathInfo, FilesystemPathInfoQuery, FilesystemPermissionFix, FirmwareErase, FirmwareErase_ex, FirmwareHash, FirmwareRequest, FirmwareUpdateEmmc, FirmwareUpload, GetAddress, GetDeviceInfo, GetECDHSessionKey, GetEntropy, GetFeatures, GetFirmwareHash, GetNextU2FCounter, GetNonce, GetOwnershipId, GetOwnershipProof, GetPassphraseState, GetPublicKey, GetPublicKeyMultiple, HDNodePathType, HDNodeType, IdentityType, Initialize, InputScriptType, InternalInputScriptType, InternalMyAddressRequest, KaspaAddress, KaspaGetAddress, KaspaInputScriptType, KaspaOutpoint, KaspaOutputScriptType, KaspaRequestType, KaspaSignTx, KaspaSignedTx, KaspaTxAckInput, KaspaTxAckOutput, KaspaTxAckPayloadChunk, KaspaTxAckPrevInput, KaspaTxAckPrevMeta, KaspaTxAckPrevOutput, KaspaTxInputAck, KaspaTxInputRequest, KaspaTxRequest, KaspaTxRequestSignature, ListResDir, LnurlAuth, LnurlAuthResp, LockDevice, LogBlockCommand, LowLevelDevice, LowlevelTransportSharedPlugin, MessageFromOneKey, MessageKey, MessageResponse, MessageResponseMap, MessageSignature, MessageType, messages as Messages, MoneroAccountPublicAddress, MoneroAddress, MoneroExportedKeyImage, MoneroGetAddress, MoneroGetTxKeyAck, MoneroGetTxKeyRequest, MoneroGetWatchKey, MoneroKeyImageExportInitAck, MoneroKeyImageExportInitRequest, MoneroKeyImageSyncFinalAck, MoneroKeyImageSyncFinalRequest, MoneroKeyImageSyncStepAck, MoneroKeyImageSyncStepRequest, MoneroLiveRefreshFinalAck, MoneroLiveRefreshFinalRequest, MoneroLiveRefreshStartAck, MoneroLiveRefreshStartRequest, MoneroLiveRefreshStepAck, MoneroLiveRefreshStepRequest, MoneroMultisigKLRki, MoneroNetworkType, MoneroOutputEntry, MoneroRctKeyPublic, MoneroRingCtSig, MoneroSubAddressIndicesList, MoneroTransactionAllInputsSetAck, MoneroTransactionAllInputsSetRequest, MoneroTransactionAllOutSetAck, MoneroTransactionAllOutSetRequest, MoneroTransactionData, MoneroTransactionDestinationEntry, MoneroTransactionFinalAck, MoneroTransactionFinalRequest, MoneroTransactionInitAck, MoneroTransactionInitRequest, MoneroTransactionInputViniAck, MoneroTransactionInputViniRequest, MoneroTransactionInputsPermutationAck, MoneroTransactionInputsPermutationRequest, MoneroTransactionRsigData, MoneroTransactionSetInputAck, MoneroTransactionSetInputRequest, MoneroTransactionSetOutputAck, MoneroTransactionSetOutputRequest, MoneroTransactionSignInputAck, MoneroTransactionSignInputRequest, MoneroTransactionSourceEntry, MoneroTransferDetails, MoneroWatchKey, MultisigRedeemScriptType, NEMAddress, NEMAggregateModification, NEMCosignatoryModification, NEMDecryptMessage, NEMDecryptedMessage, NEMGetAddress, NEMImportanceTransfer, NEMImportanceTransferMode, NEMModificationType, NEMMosaic, NEMMosaicCreation, NEMMosaicDefinition, NEMMosaicLevy, NEMMosaicSupplyChange, NEMProvisionNamespace, NEMSignTx, NEMSignedTx, NEMSupplyChangeType, NEMTransactionCommon, NEMTransfer, NFTWriteData, NFTWriteInfo, NearAddress, NearGetAddress, NearSignTx, NearSignedTx, NeoAddress, NeoGetAddress, NeoSignTx, NeoSignedTx, NervosAddress, NervosGetAddress, NervosSignTx, NervosSignedTx, NervosTxAck, NervosTxRequest, NexaAddress, NexaGetAddress, NexaSignTx, NexaSignedTx, NexaTxInputAck, NexaTxInputRequest, NextU2FCounter, NftUpdate, Nonce, NostrDecryptMessage, NostrDecryptedMessage, NostrEncryptMessage, NostrEncryptedMessage, NostrGetPublicKey, NostrPublicKey, NostrSignEvent, NostrSignSchnorr, NostrSignedEvent, NostrSignedSchnorr, OnboardingPhase, OnboardingSetupKind, OnboardingSetupMethod, OnboardingSetupStatus, OnboardingStatus, OnboardingStatusGet, OnboardingStep, OneKeyDeviceCommType, OneKeyDeviceInfo, OneKeyDeviceInfoBase, OneKeyDeviceInfoWithSession, OneKeyDeviceType, OneKeyMobileDeviceInfo, OneKeySEState, OneKeySeType, OnekeyFeatures, OnekeyGetFeatures, OutputScriptType, OwnershipId, OwnershipProof, PROTOCOL_V1_CHUNK_PAYLOAD_SIZE, PROTOCOL_V1_ENVELOPE_HEADER_SIZE, PROTOCOL_V1_HEADER_BYTE, PROTOCOL_V1_MESSAGE_HEADER_SIZE, PROTOCOL_V1_REPORT_ID, PROTOCOL_V1_USB_PACKET_SIZE, PROTOCOL_V2_BLE_FILE_CHUNK_SIZE, PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE, PROTOCOL_V2_BLE_FIRMWARE_FILE_CHUNK_SIZE, PROTOCOL_V2_BLE_FRAME_MAX_BYTES, PROTOCOL_V2_CHANNEL_BLE_UART, PROTOCOL_V2_CHANNEL_SOCKET, PROTOCOL_V2_CHANNEL_USB, PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS, PROTOCOL_V2_FILE_CHUNK_SIZE, PROTOCOL_V2_FRAME_MAX_BYTES, PROTOCOL_V2_PACKET_SRC_COMMAND, PROTOCOL_V2_SYS_MESSAGE_THRESHOLD, PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE, PassphraseAck, PassphraseRequest, PassphraseState, Path, PaymentRequestMemo, PinMatrixAck, PinMatrixRequest, PinMatrixRequestType, Ping, PolkadotAddress, PolkadotGetAddress, PolkadotSignTx, PolkadotSignedTx, PortfolioUpdate, PreauthorizedRequest, PrevInput, PrevOutput, PrevTx, ProtocolInfo, ProtocolInfoRequest, ProtocolType, ProtocolV1, ProtocolV2, ProtocolV2BleFrameWriterOptions, ProtocolV2CallContext, ProtocolV2CallOptions, ProtocolV2Capability, ProtocolV2DeviceInfo, ProtocolV2FailureType, ProtocolV2FrameAssembler, ProtocolV2LinkAdapter, ProtocolV2LinkDisabledError, ProtocolV2LinkError, ProtocolV2LinkErrorClassification, ProtocolV2LinkErrorCode, ProtocolV2LinkManager, ProtocolV2LinkManagerOptions, ProtocolV2Schemas, ProtocolV2SequenceCursor, ProtocolV2Session, ProtocolV2SessionOptions, ProtocolV2UsbTransportBase, ProtocolV2UsbTransportBaseOptions, PublicKey, PublicKeyMultiple, ReadSEPublicCert, ReadSEPublicKey, Reboot, RebootToBoardloader, RebootToBootloader, RebootType, RecoveryDevice, RecoveryDeviceType, RefundMemo, RequestType, ResetDevice, ResourceAck, ResourceRequest, ResourceType, ResourceUpdate, ResourceUpload, RippleAddress, RippleGetAddress, RipplePayment, RippleSignTx, RippleSignedTx, SEMessageSignature, SEPublicCert, SEPublicKey, SESignMessage, SafetyCheckLevel, ScdoAddress, ScdoGetAddress, ScdoSignMessage, ScdoSignTx, ScdoSignedMessage, ScdoSignedTx, ScdoTxAck, SdProtect, SdProtectOperationType, SeedRequestType, SelfTest, SetBusy, SetU2FCounter, SignIdentity, SignMessage, SignPsbt, SignTx, SignedIdentity, SignedPsbt, SolanaAddress, SolanaGetAddress, SolanaMessageSignature, SolanaOffChainMessageFormat, SolanaOffChainMessageVersion, SolanaSignOffChainMessage, SolanaSignTx, SolanaSignUnsafeMessage, SolanaSignedTx, SolanaTxATADetails, SolanaTxExtraInfo, SpiFlashData, SpiFlashRead, SpiFlashWrite, StarcoinAddress, StarcoinGetAddress, StarcoinGetPublicKey, StarcoinMessageSignature, StarcoinPublicKey, StarcoinSignMessage, StarcoinSignTx, StarcoinSignedTx, StarcoinVerifyMessage, StellarAccountMergeOp, StellarAddress, StellarAllowTrustOp, StellarAsset, StellarAssetType, StellarBumpSequenceOp, StellarChangeTrustOp, StellarCreateAccountOp, StellarCreatePassiveSellOfferOp, StellarGetAddress, StellarInvokeHostFunctionOp, StellarManageBuyOfferOp, StellarManageDataOp, StellarManageSellOfferOp, StellarMemoType, StellarPathPaymentStrictReceiveOp, StellarPathPaymentStrictSendOp, StellarPaymentOp, StellarRequestType, StellarSetOptionsOp, StellarSignTx, StellarSignedTx, StellarSignerType, StellarSorobanDataAck, StellarSorobanDataRequest, StellarTxOpRequest, Success, SuiAddress, SuiGetAddress, SuiMessageSignature, SuiSignMessage, SuiSignTx, SuiSignedTx, SuiTxAck, SuiTxRequest, TRANSPORT_EVENT, TextMemo, TezosAddress, TezosBallotOp, TezosBallotType, TezosContractID, TezosContractType, TezosDelegationOp, TezosGetAddress, TezosGetPublicKey, TezosManagerTransfer, TezosOriginationOp, TezosParametersManager, TezosProposalOp, TezosPublicKey, TezosRevealOp, TezosSignTx, TezosSignedTx, TezosTransactionOp, TonAddress, TonGetAddress, TonSignData, TonSignDataType, TonSignMessage, TonSignProof, TonSignedData, TonSignedMessage, TonSignedProof, TonTxAck, TonWalletVersion, TonWorkChain, Transport, TransportCallOptions, TransportDeviceDisconnectEvent, TransportWriteMetrics, TronAddress, TronCancelAllUnfreezeV2Contract, TronContract, TronDelegateResourceContract, TronFreezeBalanceContract, TronFreezeBalanceV2Contract, TronGetAddress, TronMessageSignature, TronMessageType, TronResourceCode, TronSignMessage, TronSignTx, TronSignedTx, TronTransferContract, TronTriggerSmartContract, TronUnDelegateResourceContract, TronUnfreezeBalanceContract, TronUnfreezeBalanceV2Contract, TronVoteWitnessContract, TronWithdrawBalanceContract, TronWithdrawExpireUnfreezeContract, TxAck, TxAckInput, TxAckInputWrapper, TxAckOutput, TxAckOutputWrapper, TxAckPaymentRequest, TxAckPrevExtraData, TxAckPrevExtraDataWrapper, TxAckPrevInput, TxAckPrevInputWrapper, TxAckPrevMeta, TxAckPrevOutput, TxAckPrevOutputWrapper, TxAckResponse, TxInput, TxInputType, TxOutput, TxOutputBinType, TxOutputType, TxRequest, TxRequestDetailsType, TxRequestSerializedType, TypedCall, UiAnimationCommand, UiAnimationRequest, UiAnimationType, UintType, UnLockDevice, UnLockDeviceResponse, UnlockPath, UnlockedPathRequest, UpgradeFileHeader, VerifyMessage, ViewActionCard, ViewAmount, ViewContentEntry, ViewContentPage, ViewContentPreview, ViewCustomField, ViewDetail, ViewSignLayout, ViewSignPage, ViewTip, ViewTipType, ViewVerifyPage, ViewWarningPage, Vote, WL_OperationType, WipeDevice, WordAck, WordRequest, WordRequestType, WriteSEPrivateKey, WriteSEPublicCert, ZoomRequest, bytesToHex, concatUint8Arrays, createProtocolV2LinkDisabledError, createTransportCallLog, _default as default, detectProtocolV2LinkDisabledError, experimental_field, experimental_message, facotry, getErrorMessage, getSafeTransportLogPayload, hexToBytes, isProtocolV2HighThroughputCall, isProtocolV2LinkDisabledError, isProtocolV2LinkDisabledFailure, isProtocolV2LinkError, probeProtocolV2, index as protocolV1, protocolV2Codec as protocolV2, shouldSuppressHighVolumeCallLog, withProtocolTimeout, writeProtocolV2BleFrame };
+export { AcquireInput, Address, AlephiumAddress, AlephiumBytecodeAck, AlephiumBytecodeRequest, AlephiumGetAddress, AlephiumMessageSignature, AlephiumSignMessage, AlephiumSignTx, AlephiumSignedTx, AlephiumTxAck, AlephiumTxRequest, AlgorandAddress, AlgorandGetAddress, AlgorandSignTx, AlgorandSignedTx, AmountUnit, ApplyFlags, ApplySettings, AptosAddress, AptosGetAddress, AptosMessagePayload, AptosMessageSignature, AptosSignMessage, AptosSignSIWAMessage, AptosSignTx, AptosSignedTx, AptosTransactionType, AuthorizeCoinJoin, BIP32Address, BabylonDeriveContextHash, BabylonDerivedContextHash, BackupDevice, BackupType, BatchGetPublickeys, BenfenAddress, BenfenGetAddress, BenfenMessageSignature, BenfenSignMessage, BenfenSignTx, BenfenSignedTx, BenfenTxAck, BenfenTxRequest, BinanceAddress, BinanceCancelMsg, BinanceCoin, BinanceGetAddress, BinanceGetPublicKey, BinanceInputOutput, BinanceOrderMsg, BinanceOrderSide, BinanceOrderType, BinancePublicKey, BinanceSignTx, BinanceSignedTx, BinanceTimeInForce, BinanceTransferMsg, BinanceTxRequest, BixinBackupAck, BixinBackupDevice, BixinBackupDeviceAck, BixinBackupRequest, BixinLoadDevice, BixinMessageSE, BixinOutMessageSE, BixinPinInputOnDevice, BixinRestoreAck, BixinRestoreRequest, BixinSeedOperate, BixinVerifyDeviceAck, BixinVerifyDeviceRequest, BixinWhiteListAck, BixinWhiteListRequest, BlurRequest, ButtonAck, ButtonRequest, ButtonRequestType, Cancel, CancelAuthorization, CanonicalBitcoinNetwork, Capability, CardanoAddress, CardanoAddressParametersType, CardanoAddressType, CardanoAssetGroup, CardanoBlockchainPointerType, CardanoCVoteRegistrationDelegation, CardanoCVoteRegistrationFormat, CardanoCVoteRegistrationParametersType, CardanoCertificateType, CardanoDRep, CardanoDRepType, CardanoDerivationType, CardanoGetAddress, CardanoGetNativeScriptHash, CardanoGetPublicKey, CardanoMessageSignature, CardanoNativeScript, CardanoNativeScriptHash, CardanoNativeScriptHashDisplayFormat, CardanoNativeScriptType, CardanoPoolMetadataType, CardanoPoolOwner, CardanoPoolParametersType, CardanoPoolRelayParameters, CardanoPoolRelayType, CardanoPublicKey, CardanoSignMessage, CardanoSignTxFinished, CardanoSignTxInit, CardanoToken, CardanoTxAuxiliaryData, CardanoTxAuxiliaryDataSupplement, CardanoTxAuxiliaryDataSupplementType, CardanoTxBodyHash, CardanoTxCertificate, CardanoTxCollateralInput, CardanoTxHostAck, CardanoTxInlineDatumChunk, CardanoTxInput, CardanoTxItemAck, CardanoTxMint, CardanoTxOutput, CardanoTxOutputSerializationFormat, CardanoTxReferenceInput, CardanoTxReferenceScriptChunk, CardanoTxRequiredSigner, CardanoTxSigningMode, CardanoTxWithdrawal, CardanoTxWitnessRequest, CardanoTxWitnessResponse, CardanoTxWitnessType, ChangeOutputScriptType, ChangePin, ChangeWipeCode, CipherKeyValue, CipheredKeyValue, CoinJoinRequest, CoinPurchaseMemo, CommandFlags, ConfluxAddress, ConfluxGetAddress, ConfluxMessageSignature, ConfluxSignMessage, ConfluxSignMessageCIP23, ConfluxSignTx, ConfluxTxAck, ConfluxTxRequest, CosmosAddress, CosmosGetAddress, CosmosSignTx, CosmosSignedTx, DecredStakingSpendType, Deprecated_PassphraseStateAck, Deprecated_PassphraseStateRequest, DeviceAnimationAction, DeviceAnimationControl, DeviceBackToBoot, DeviceCertificate, DeviceCertificateRead, DeviceCertificateSign, DeviceCertificateSignature, DeviceCertificateWrite, DeviceCoprocessorInfo, DeviceEraseSector, DeviceErrorCode, DeviceFactoryAck, DeviceFactoryInfo, DeviceFactoryInfoGet, DeviceFactoryInfoManufactureTime, DeviceFactoryInfoSet, DeviceFactoryPermanentLock, DeviceFactoryTest, DeviceFindMyTokenState, DeviceFindMyTokenStateGet, DeviceFindMyTokenUpdate, DeviceFirmwareImageInfo, DeviceFirmwareTarget, DeviceFirmwareTargetType, DeviceFirmwareUpdatePhase, DeviceFirmwareUpdatePhaseInfo, DeviceFirmwareUpdateRecord, DeviceFirmwareUpdateRecordFields, DeviceFirmwareUpdateRequest, DeviceFirmwareUpdateStage, DeviceFirmwareUpdateStatus, DeviceFirmwareUpdateStatusGet, DeviceFirmwareUpdateTaskStatus, DeviceHardwareInfo, DeviceInfo, DeviceInfoGet, DeviceInfoSettings, DeviceInfoTargets, DeviceInfoTypes, DeviceMainMcuInfo, DeviceMiscUsbMscControl, DeviceReboot, DeviceRebootType, DeviceSEInfo, DeviceSEState, DeviceSeType, DeviceSession, DeviceSessionAskPassphrase, DeviceSessionAskPin, DeviceSessionAskPin_FailureSubCodes, DeviceSessionErrorCode, DeviceSessionGet, DeviceSessionPinType, DeviceSessionSeedDomain, DeviceSettings, DeviceSettingsGet, DeviceSettingsPage, DeviceSettingsPageShow, DeviceSettingsSet, DeviceStatus, DeviceStatusGet, DeviceType, DnxAddress, DnxComputedKeyImage, DnxGetAddress, DnxInputAck, DnxInputRequest, DnxRTSigsRequest, DnxSignTx, DnxSignedTx, DnxTxKey, DoPreauthorized, ECDHSessionKey, EcdsaPublicKeys, EmmcDir, EmmcDirList, EmmcDirMake, EmmcDirRemove, EmmcFile, EmmcFileDelete, EmmcFileRead, EmmcFileWrite, EmmcFixPermission, EmmcPath, EmmcPathInfo, EndSession, Entropy, EntropyAck, EntropyRequest, Enum_BackupType, Enum_ButtonRequestType, Enum_CanonicalBitcoinNetwork, Enum_Capability, Enum_InputScriptType, Enum_KaspaInputScriptType, Enum_KaspaOutputScriptType, Enum_KaspaRequestType, Enum_OutputScriptType, Enum_PinMatrixRequestType, Enum_ProtocolV2Capability, Enum_RequestType, Enum_SafetyCheckLevel, Enum_WordRequestType, EosActionBuyRam, EosActionBuyRamBytes, EosActionCommon, EosActionDelegate, EosActionDeleteAuth, EosActionLinkAuth, EosActionNewAccount, EosActionRefund, EosActionSellRam, EosActionTransfer, EosActionUndelegate, EosActionUnknown, EosActionUnlinkAuth, EosActionUpdateAuth, EosActionVoteProducer, EosAsset, EosAuthorization, EosAuthorizationAccount, EosAuthorizationKey, EosAuthorizationWait, EosGetPublicKey, EosPermissionLevel, EosPublicKey, EosSignTx, EosSignedTx, EosTxActionAck, EosTxActionRequest, EosTxHeader, EthereumAccessList, EthereumAccessListOneKey, EthereumAddress, EthereumAddressOneKey, EthereumAuthorizationOneKey, EthereumAuthorizationSignature, EthereumDataType, EthereumDataTypeOneKey, EthereumDefinitionType, EthereumDefinitions, EthereumFieldType, EthereumFieldTypeOneKey, EthereumGetAddress, EthereumGetAddressOneKey, EthereumGetPublicKey, EthereumGetPublicKeyOneKey, EthereumGnosisSafeTxAck, EthereumGnosisSafeTxOperation, EthereumGnosisSafeTxRequest, EthereumMessageSignature, EthereumMessageSignatureOneKey, EthereumNetworkInfo, EthereumPublicKey, EthereumPublicKeyOneKey, EthereumSignMessage, EthereumSignMessageEIP712, EthereumSignMessageOneKey, EthereumSignTx, EthereumSignTxEIP1559, EthereumSignTxEIP1559OneKey, EthereumSignTxEIP7702OneKey, EthereumSignTxOneKey, EthereumSignTypedData, EthereumSignTypedDataOneKey, EthereumSignTypedDataQR, EthereumSignTypedHash, EthereumSignTypedHashOneKey, EthereumStructMember, EthereumStructMemberOneKey, EthereumTokenInfo, EthereumTxAck, EthereumTxAckOneKey, EthereumTxRequest, EthereumTxRequestOneKey, EthereumTypedDataSignature, EthereumTypedDataSignatureOneKey, EthereumTypedDataStructAck, EthereumTypedDataStructAckOneKey, EthereumTypedDataStructRequest, EthereumTypedDataStructRequestOneKey, EthereumTypedDataValueAck, EthereumTypedDataValueAckOneKey, EthereumTypedDataValueRequest, EthereumTypedDataValueRequestOneKey, EthereumVerifyMessage, EthereumVerifyMessageOneKey, ExportType, Failure, FailureType, Features, FileInfo, FileInfoList, FilecoinAddress, FilecoinGetAddress, FilecoinSignTx, FilecoinSignedTx, FilesystemDir, FilesystemDirList, FilesystemDirMake, FilesystemDirRemove, FilesystemFile, FilesystemFileDelete, FilesystemFileRead, FilesystemFileWrite, FilesystemFormat, FilesystemPathInfo, FilesystemPathInfoQuery, FilesystemPermissionFix, FirmwareErase, FirmwareErase_ex, FirmwareHash, FirmwareRequest, FirmwareUpdateEmmc, FirmwareUpload, GetAddress, GetDeviceInfo, GetECDHSessionKey, GetEntropy, GetFeatures, GetFirmwareHash, GetNextU2FCounter, GetNonce, GetOwnershipId, GetOwnershipProof, GetPassphraseState, GetPublicKey, GetPublicKeyMultiple, HDNodePathType, HDNodeType, IdentityType, Initialize, InputScriptType, InternalInputScriptType, InternalMyAddressRequest, KaspaAddress, KaspaGetAddress, KaspaInputScriptType, KaspaOutpoint, KaspaOutputScriptType, KaspaRequestType, KaspaSignTx, KaspaSignedTx, KaspaTxAckInput, KaspaTxAckOutput, KaspaTxAckPayloadChunk, KaspaTxAckPrevInput, KaspaTxAckPrevMeta, KaspaTxAckPrevOutput, KaspaTxInputAck, KaspaTxInputRequest, KaspaTxRequest, KaspaTxRequestSignature, ListResDir, LnurlAuth, LnurlAuthResp, LockDevice, LogBlockCommand, LowLevelDevice, LowlevelTransportSharedPlugin, MessageFromOneKey, MessageKey, MessageResponse, MessageResponseMap, MessageSignature, MessageType, messages as Messages, MoneroAccountPublicAddress, MoneroAddress, MoneroExportedKeyImage, MoneroGetAddress, MoneroGetTxKeyAck, MoneroGetTxKeyRequest, MoneroGetWatchKey, MoneroKeyImageExportInitAck, MoneroKeyImageExportInitRequest, MoneroKeyImageSyncFinalAck, MoneroKeyImageSyncFinalRequest, MoneroKeyImageSyncStepAck, MoneroKeyImageSyncStepRequest, MoneroLiveRefreshFinalAck, MoneroLiveRefreshFinalRequest, MoneroLiveRefreshStartAck, MoneroLiveRefreshStartRequest, MoneroLiveRefreshStepAck, MoneroLiveRefreshStepRequest, MoneroMultisigKLRki, MoneroNetworkType, MoneroOutputEntry, MoneroRctKeyPublic, MoneroRingCtSig, MoneroSubAddressIndicesList, MoneroTransactionAllInputsSetAck, MoneroTransactionAllInputsSetRequest, MoneroTransactionAllOutSetAck, MoneroTransactionAllOutSetRequest, MoneroTransactionData, MoneroTransactionDestinationEntry, MoneroTransactionFinalAck, MoneroTransactionFinalRequest, MoneroTransactionInitAck, MoneroTransactionInitRequest, MoneroTransactionInputViniAck, MoneroTransactionInputViniRequest, MoneroTransactionInputsPermutationAck, MoneroTransactionInputsPermutationRequest, MoneroTransactionRsigData, MoneroTransactionSetInputAck, MoneroTransactionSetInputRequest, MoneroTransactionSetOutputAck, MoneroTransactionSetOutputRequest, MoneroTransactionSignInputAck, MoneroTransactionSignInputRequest, MoneroTransactionSourceEntry, MoneroTransferDetails, MoneroWatchKey, MultisigRedeemScriptType, NEMAddress, NEMAggregateModification, NEMCosignatoryModification, NEMDecryptMessage, NEMDecryptedMessage, NEMGetAddress, NEMImportanceTransfer, NEMImportanceTransferMode, NEMModificationType, NEMMosaic, NEMMosaicCreation, NEMMosaicDefinition, NEMMosaicLevy, NEMMosaicSupplyChange, NEMProvisionNamespace, NEMSignTx, NEMSignedTx, NEMSupplyChangeType, NEMTransactionCommon, NEMTransfer, NFTWriteData, NFTWriteInfo, NearAddress, NearGetAddress, NearSignTx, NearSignedTx, NeoAddress, NeoGetAddress, NeoSignTx, NeoSignedTx, NervosAddress, NervosGetAddress, NervosSignTx, NervosSignedTx, NervosTxAck, NervosTxRequest, NexaAddress, NexaGetAddress, NexaSignTx, NexaSignedTx, NexaTxInputAck, NexaTxInputRequest, NextU2FCounter, NftUpdate, Nonce, NostrDecryptMessage, NostrDecryptedMessage, NostrEncryptMessage, NostrEncryptedMessage, NostrGetPublicKey, NostrPublicKey, NostrSignEvent, NostrSignSchnorr, NostrSignedEvent, NostrSignedSchnorr, OnboardingPhase, OnboardingSetupKind, OnboardingSetupMethod, OnboardingSetupStatus, OnboardingStatus, OnboardingStatusGet, OnboardingStep, OneKeyDeviceCommType, OneKeyDeviceInfo, OneKeyDeviceInfoBase, OneKeyDeviceInfoWithSession, OneKeyDeviceType, OneKeyMobileDeviceInfo, OneKeySEState, OneKeySeType, OnekeyFeatures, OnekeyGetFeatures, OutputScriptType, OwnershipId, OwnershipProof, PROTOCOL_V1_CHUNK_PAYLOAD_SIZE, PROTOCOL_V1_ENVELOPE_HEADER_SIZE, PROTOCOL_V1_HEADER_BYTE, PROTOCOL_V1_MESSAGE_HEADER_SIZE, PROTOCOL_V1_REPORT_ID, PROTOCOL_V1_USB_PACKET_SIZE, PROTOCOL_V2_BLE_FILE_CHUNK_SIZE, PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE, PROTOCOL_V2_BLE_FIRMWARE_FILE_CHUNK_SIZE, PROTOCOL_V2_BLE_FRAME_MAX_BYTES, PROTOCOL_V2_CHANNEL_BLE_UART, PROTOCOL_V2_CHANNEL_SOCKET, PROTOCOL_V2_CHANNEL_USB, PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS, PROTOCOL_V2_FILE_CHUNK_SIZE, PROTOCOL_V2_FILE_WRITE_PIPELINE_WINDOW, PROTOCOL_V2_FRAME_MAX_BYTES, PROTOCOL_V2_PACKET_SRC_COMMAND, PROTOCOL_V2_SYS_MESSAGE_THRESHOLD, PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE, PassphraseAck, PassphraseRequest, PassphraseState, Path, PaymentRequestMemo, PinMatrixAck, PinMatrixRequest, PinMatrixRequestType, Ping, PolkadotAddress, PolkadotGetAddress, PolkadotSignTx, PolkadotSignedTx, PortfolioUpdate, PreauthorizedRequest, PrevInput, PrevOutput, PrevTx, ProtocolInfo, ProtocolInfoRequest, ProtocolType, ProtocolV1, ProtocolV2, ProtocolV2BleFrameWriterOptions, ProtocolV2CallContext, ProtocolV2CallOptions, ProtocolV2Capability, ProtocolV2DeviceInfo, ProtocolV2FailureType, ProtocolV2FileWritePipeline, ProtocolV2FrameAssembler, ProtocolV2LinkAdapter, ProtocolV2LinkDisabledError, ProtocolV2LinkError, ProtocolV2LinkErrorClassification, ProtocolV2LinkErrorCode, ProtocolV2LinkManager, ProtocolV2LinkManagerOptions, ProtocolV2Schemas, ProtocolV2SequenceCursor, ProtocolV2Session, ProtocolV2SessionOptions, ProtocolV2UsbTransportBase, ProtocolV2UsbTransportBaseOptions, PublicKey, PublicKeyMultiple, ReadSEPublicCert, ReadSEPublicKey, Reboot, RebootToBoardloader, RebootToBootloader, RebootType, RecoveryDevice, RecoveryDeviceType, RefundMemo, RequestType, ResetDevice, ResourceAck, ResourceRequest, ResourceType, ResourceUpdate, ResourceUpload, RippleAddress, RippleGetAddress, RipplePayment, RippleSignTx, RippleSignedTx, SEMessageSignature, SEPublicCert, SEPublicKey, SESignMessage, SafetyCheckLevel, ScdoAddress, ScdoGetAddress, ScdoSignMessage, ScdoSignTx, ScdoSignedMessage, ScdoSignedTx, ScdoTxAck, SdProtect, SdProtectOperationType, SeedRequestType, SelfTest, SetBusy, SetU2FCounter, SignIdentity, SignMessage, SignPsbt, SignTx, SignedIdentity, SignedPsbt, SolanaAddress, SolanaGetAddress, SolanaMessageSignature, SolanaOffChainMessageFormat, SolanaOffChainMessageVersion, SolanaSignOffChainMessage, SolanaSignTx, SolanaSignUnsafeMessage, SolanaSignedTx, SolanaTxATADetails, SolanaTxExtraInfo, SpiFlashData, SpiFlashRead, SpiFlashWrite, StarcoinAddress, StarcoinGetAddress, StarcoinGetPublicKey, StarcoinMessageSignature, StarcoinPublicKey, StarcoinSignMessage, StarcoinSignTx, StarcoinSignedTx, StarcoinVerifyMessage, StellarAccountMergeOp, StellarAddress, StellarAllowTrustOp, StellarAsset, StellarAssetType, StellarBumpSequenceOp, StellarChangeTrustOp, StellarCreateAccountOp, StellarCreatePassiveSellOfferOp, StellarGetAddress, StellarInvokeHostFunctionOp, StellarManageBuyOfferOp, StellarManageDataOp, StellarManageSellOfferOp, StellarMemoType, StellarPathPaymentStrictReceiveOp, StellarPathPaymentStrictSendOp, StellarPaymentOp, StellarRequestType, StellarSetOptionsOp, StellarSignTx, StellarSignedTx, StellarSignerType, StellarSorobanDataAck, StellarSorobanDataRequest, StellarTxOpRequest, Success, SuiAddress, SuiGetAddress, SuiMessageSignature, SuiSignMessage, SuiSignTx, SuiSignedTx, SuiTxAck, SuiTxRequest, TRANSPORT_EVENT, TextMemo, TezosAddress, TezosBallotOp, TezosBallotType, TezosContractID, TezosContractType, TezosDelegationOp, TezosGetAddress, TezosGetPublicKey, TezosManagerTransfer, TezosOriginationOp, TezosParametersManager, TezosProposalOp, TezosPublicKey, TezosRevealOp, TezosSignTx, TezosSignedTx, TezosTransactionOp, TonAddress, TonGetAddress, TonSignData, TonSignDataType, TonSignMessage, TonSignProof, TonSignedData, TonSignedMessage, TonSignedProof, TonTxAck, TonWalletVersion, TonWorkChain, Transport, TransportCallOptions, TransportDeviceDisconnectEvent, TransportWriteMetrics, TronAddress, TronCancelAllUnfreezeV2Contract, TronContract, TronDelegateResourceContract, TronFreezeBalanceContract, TronFreezeBalanceV2Contract, TronGetAddress, TronMessageSignature, TronMessageType, TronResourceCode, TronSignMessage, TronSignTx, TronSignedTx, TronTransferContract, TronTriggerSmartContract, TronUnDelegateResourceContract, TronUnfreezeBalanceContract, TronUnfreezeBalanceV2Contract, TronVoteWitnessContract, TronWithdrawBalanceContract, TronWithdrawExpireUnfreezeContract, TxAck, TxAckInput, TxAckInputWrapper, TxAckOutput, TxAckOutputWrapper, TxAckPaymentRequest, TxAckPrevExtraData, TxAckPrevExtraDataWrapper, TxAckPrevInput, TxAckPrevInputWrapper, TxAckPrevMeta, TxAckPrevOutput, TxAckPrevOutputWrapper, TxAckResponse, TxInput, TxInputType, TxOutput, TxOutputBinType, TxOutputType, TxRequest, TxRequestDetailsType, TxRequestSerializedType, TypedCall, UiAnimationCommand, UiAnimationRequest, UiAnimationType, UintType, UnLockDevice, UnLockDeviceResponse, UnlockPath, UnlockedPathRequest, UpgradeFileHeader, VerifyMessage, ViewActionCard, ViewAmount, ViewContentEntry, ViewContentPage, ViewContentPreview, ViewCustomField, ViewDetail, ViewSignLayout, ViewSignPage, ViewTip, ViewTipType, ViewVerifyPage, ViewWarningPage, Vote, WL_OperationType, WipeDevice, WordAck, WordRequest, WordRequestType, WriteSEPrivateKey, WriteSEPublicCert, ZoomRequest, bytesToHex, concatUint8Arrays, createProtocolV2LinkDisabledError, createTransportCallLog, _default as default, detectProtocolV2LinkDisabledError, experimental_field, experimental_message, facotry, getErrorMessage, getSafeTransportLogPayload, hexToBytes, isProtocolV2HighThroughputCall, isProtocolV2LinkDisabledError, isProtocolV2LinkDisabledFailure, isProtocolV2LinkError, probeProtocolV2, index as protocolV1, protocolV2Codec as protocolV2, shouldSuppressHighVolumeCallLog, withProtocolTimeout, writeProtocolV2BleFrame };