@onekeyfe/hd-transport 1.2.0-alpha.18 → 1.2.0-alpha.181

package/__tests__/messages.test.js

@@ -3,6 +3,7 @@ const {
   createMessageFromType,
   parseConfigure,
 } = require('../src/serialization/protobuf/messages');
+const { encode } = require('../src/serialization/protobuf/encode');
 const v1Messages = require('../../core/src/data/messages/messages.json');
 const v2Messages = require('../messages-protocol-v2.json');
 const coreV2Messages = require('../../core/src/data/messages/messages-protocol-v2.json');
@@ -101,61 +102,165 @@ describe('messages', () => {
     expect(v2Messages.nested.MessageType.values).toMatchObject({
       MessageType_DeviceStatusGet: 60602,
       MessageType_DeviceStatus: 60603,
-      MessageType_DeviceSessionOpen: 60606,
-      MessageType_DeviceSession: 60607,
-      MessageType_DeviceSessionAskPin: 60608,
+      MessageType_DeviceSessionGet: 61200,
+      MessageType_DeviceSession: 61201,
+      MessageType_DeviceSessionAskPin: 61202,
+      MessageType_DeviceSessionAskPassphrase: 61203,
     });
     expect(v2Messages.nested.DeviceStatusGet).toEqual({ fields: {} });
-    expect(v2Messages.nested.DeviceSessionResume.fields.session_id).toMatchObject({
+    expect(v2Messages.nested.ProtocolInfoRequest.fields.eventless_wallet_session).toMatchObject({
+      id: 1,
+      type: 'bool',
+      options: { default: false },
+    });
+    expect(v2Messages.nested.ProtocolInfo.fields).toMatchObject({
+      version: { id: 1, type: 'uint32', rule: 'required' },
+      build_fingerprint: { id: 2, type: 'string', rule: 'required' },
+      supported_messages: { id: 3, type: 'uint32', rule: 'repeated' },
+    });
+    expect(v2Messages.nested.DeviceSessionGet.fields.session_id).toMatchObject({
       id: 1,
       type: 'bytes',
     });
-    expect(v2Messages.nested.DeviceWalletSelect.oneofs.access.oneof).toEqual([
-      'host_passphrase',
-      'passphrase_on_device',
-      'attach_pin_on_device',
-    ]);
-    expect(v2Messages.nested.DeviceSessionOpen.oneofs.mode.oneof).toEqual(['resume', 'select']);
+    expect(v2Messages.nested.DeviceSessionGet.fields).toEqual({
+      session_id: { id: 1, type: 'bytes' },
+      btc_test_address: { id: 2, type: 'string' },
+      seed_domains: {
+        id: 3,
+        rule: 'repeated',
+        type: 'DeviceSessionSeedDomain',
+      },
+    });
+    expect(v2Messages.nested.DeviceSessionSeedDomain.values).toEqual({
+      SeedDomain_Standard: 1,
+      SeedDomain_Cardano: 2,
+    });
+    expect(v2Messages.nested.DeviceSessionPinType.values).toEqual({
+      Any: 1,
+      Main: 2,
+      AttachToPin: 3,
+    });
+    expect(v2Messages.nested.DeviceSessionErrorCode.values).toEqual({
+      DeviceSessionError_None: 0,
+      DeviceSessionError_UserCancelled: 1,
+      DeviceSessionError_InvalidSession: 2,
+      DeviceSessionError_AttachPinUnavailable: 3,
+      DeviceSessionError_PassphraseDisabled: 4,
+      DeviceSessionError_Busy: 5,
+    });
+    expect(v2Messages.nested).not.toHaveProperty('DeviceWalletSelect');
     expect(v2Messages.nested).not.toHaveProperty('DeviceWalletType');
     expect(v2Messages.nested).not.toHaveProperty('DeviceHiddenWalletSelect');
     expect(v2Messages.nested.DeviceSession.fields).toMatchObject({
       session_id: { id: 1, type: 'bytes' },
       btc_test_address: { id: 2, type: 'string' },
     });
-    expect(v2Messages.nested.DeviceSessionAskPin).toEqual({ fields: {} });
+    expect(v2Messages.nested.DeviceSessionAskPin.fields.type).toMatchObject({
+      id: 1,
+      type: 'DeviceSessionPinType',
+    });
+    expect(v2Messages.nested.DeviceSessionAskPassphrase).toEqual({
+      fields: {
+        passphrase: {
+          type: 'string',
+          id: 1,
+        },
+        on_device: {
+          rule: 'required',
+          type: 'bool',
+          id: 2,
+        },
+      },
+    });
     expect(v2Messages.nested.DeviceSessionAskPin_FailureSubCodes.values).toEqual({
       UserCancel: 1,
     });
     expect(v2Messages.nested.MessageType.values).not.toHaveProperty(
       'MessageType_DeviceSessionPinResult'
     );
-    expect(v2Messages.nested.MessageType.values).not.toHaveProperty('MessageType_DeviceSessionGet');
+    expect(v2Messages.nested.MessageType.values).not.toHaveProperty(
+      'MessageType_DeviceSessionOpen'
+    );
+  });
+
+  test('Protocol V2 passphrase selection explicitly selects host or device input on wire', () => {
+    const messages = parseConfigure(v2Messages);
+    const { Message } = createMessageFromName(messages, 'DeviceSessionAskPassphrase');
+
+    const standardWallet = encode(Message, { passphrase: '', on_device: false });
+    const onHost = Message.encode(
+      Message.create({ passphrase: 'host hidden wallet', on_device: false })
+    ).finish();
+    const onDevice = Message.encode(Message.create({ on_device: true })).finish();
+
+    expect(standardWallet.toString('hex')).toBe('0a001000');
+    expect(Buffer.from(onHost).toString('hex')).toBe(
+      '0a12686f73742068696464656e2077616c6c65741000'
+    );
+    expect(Buffer.from(onDevice).toString('hex')).toBe('1001');
+    expect(Message.decode(onHost)).toMatchObject({
+      passphrase: 'host hidden wallet',
+      on_device: false,
+    });
+    expect(Message.decode(onDevice)).toMatchObject({ on_device: true });
+  });
+
+  test('Protocol V2 wallet recovery carries the expected wallet and seed domains on wire', () => {
+    const messages = parseConfigure(v2Messages);
+    const { Message } = createMessageFromName(messages, 'DeviceSessionGet');
+    const payload = encode(Message, {
+      btc_test_address: 'tb1qwallet',
+      seed_domains: [
+        generatedTypes.DeviceSessionSeedDomain.SeedDomain_Standard,
+        generatedTypes.DeviceSessionSeedDomain.SeedDomain_Cardano,
+      ],
+    });
+
+    expect(payload.toString('hex')).toBe('120a7462317177616c6c65741a020102');
+    expect(Message.decode(payload.toBuffer())).toMatchObject({
+      btc_test_address: 'tb1qwallet',
+      seed_domains: [
+        generatedTypes.DeviceSessionSeedDomain.SeedDomain_Standard,
+        generatedTypes.DeviceSessionSeedDomain.SeedDomain_Cardano,
+      ],
+    });
   });
 
   test('Protocol V2 onboarding status matches the current firmware-pro2 schema', () => {
-    expect(v2Messages.nested.DevOnboardingStep.values).toMatchObject({
-      DEV_ONBOARDING_STEP_UNKNOWN: 0,
-      DEV_ONBOARDING_STEP_CHECKING: 1,
-      DEV_ONBOARDING_STEP_PERSONALIZATION: 2,
-      DEV_ONBOARDING_STEP_PIN: 3,
-      DEV_ONBOARDING_STEP_SETUP: 4,
-      DEV_ONBOARDING_STEP_DONE: 5,
-    });
-    expect(v2Messages.nested.DevOnboardingPhase.values).toBeDefined();
-    expect(v2Messages.nested.DevOnboardingSetupKind.values).toBeDefined();
-    expect(v2Messages.nested.DevOnboardingSetupMethod.values).toBeDefined();
-    expect(v2Messages.nested.DevOnboardingSetupStatus.fields).toMatchObject({
-      kind: { id: 1, type: 'DevOnboardingSetupKind' },
-      method: { id: 2, type: 'DevOnboardingSetupMethod' },
-    });
-    expect(v2Messages.nested.DevOnboardingStatus.fields).toMatchObject({
-      step: { id: 1, type: 'DevOnboardingStep' },
-      phase: { id: 2, type: 'DevOnboardingPhase' },
-      setup: { id: 3, type: 'DevOnboardingSetupStatus' },
+    expect(v2Messages.nested.MessageType.values).toMatchObject({
+      MessageType_OnboardingStatusGet: 61600,
+      MessageType_OnboardingStatus: 61601,
+    });
+    expect(v2Messages.nested.OnboardingStep.values).toMatchObject({
+      ONBOARDING_STEP_UNKNOWN: 0,
+      ONBOARDING_STEP_CHECKING: 1,
+      ONBOARDING_STEP_PERSONALIZATION: 2,
+      ONBOARDING_STEP_PIN: 3,
+      ONBOARDING_STEP_SETUP: 4,
+      ONBOARDING_STEP_DONE: 5,
+    });
+    expect(v2Messages.nested.OnboardingPhase.values).toBeDefined();
+    expect(v2Messages.nested.OnboardingSetupKind.values).toBeDefined();
+    expect(v2Messages.nested.OnboardingSetupMethod.values).toBeDefined();
+    expect(v2Messages.nested.OnboardingSetupStatus.fields).toMatchObject({
+      kind: { id: 1, type: 'OnboardingSetupKind' },
+      method: { id: 2, type: 'OnboardingSetupMethod' },
+    });
+    expect(v2Messages.nested.OnboardingStatus.fields).toMatchObject({
+      step: { id: 1, type: 'OnboardingStep' },
+      phase: { id: 2, type: 'OnboardingPhase' },
+      setup: { id: 3, type: 'OnboardingSetupStatus' },
       pin_set: { id: 4, type: 'bool' },
       wallet_initialized: { id: 5, type: 'bool' },
     });
-    expect(v2Messages.nested).not.toHaveProperty('DevOnboardingStage');
+    expect(v2Messages.nested).not.toHaveProperty('DevOnboardingStatus');
+  });
+
+  test('Protocol V2 NFT update matches the current firmware-pro2 schema', () => {
+    expect(v2Messages.nested.MessageType.values.MessageType_NftUpdate).toBe(61500);
+    expect(v2Messages.nested.NftUpdate.fields).toEqual({
+      file_name_no_ext: { id: 1, type: 'string', rule: 'required' },
+    });
   });
 
   test('Protocol V2 does not restore retired unlock or passphrase ids', () => {

package/__tests__/protocol-v2-ble-frame-writer.test.js

@@ -0,0 +1,119 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+const { writeProtocolV2BleFrame } = require('../src');
+
+describe('Protocol V2 BLE frame writer', () => {
+  test('splits one complete Protocol V2 frame without changing packet order', async () => {
+    const packets = [];
+
+    await writeProtocolV2BleFrame({
+      frame: new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
+      packetCapacity: 4,
+      writePacket: packet => {
+        packets.push(Array.from(packet));
+        return Promise.resolve();
+      },
+    });
+
+    expect(packets).toEqual([
+      [0, 1, 2, 3],
+      [4, 5, 6, 7],
+      [8, 9],
+    ]);
+  });
+
+  test('stops before the next packet when the connection generation changes', async () => {
+    const packets = [];
+    let active = true;
+
+    await expect(
+      writeProtocolV2BleFrame({
+        frame: new Uint8Array(9),
+        packetCapacity: 4,
+        assertActive: () => {
+          if (!active) throw new Error('stale BLE generation');
+        },
+        writePacket: packet => {
+          packets.push(packet);
+          active = false;
+          return Promise.resolve();
+        },
+      })
+    ).rejects.toThrow('stale BLE generation');
+
+    expect(packets).toHaveLength(1);
+  });
+
+  test('does not write when the call is already aborted', async () => {
+    const controller = new AbortController();
+    const writePacket = jest.fn();
+    controller.abort();
+
+    await expect(
+      writeProtocolV2BleFrame({
+        frame: new Uint8Array(4),
+        packetCapacity: 4,
+        signal: controller.signal,
+        abortMessage: 'Protocol V2 BLE write aborted for Ping',
+        writePacket,
+      })
+    ).rejects.toThrow('Protocol V2 BLE write aborted for Ping');
+
+    expect(writePacket).not.toHaveBeenCalled();
+  });
+
+  test('surfaces an abort that occurs while the final packet write is completing', async () => {
+    const controller = new AbortController();
+    const writePacket = jest.fn().mockImplementation(() => {
+      controller.abort();
+      return Promise.resolve();
+    });
+
+    await expect(
+      writeProtocolV2BleFrame({
+        frame: new Uint8Array(4),
+        packetCapacity: 4,
+        signal: controller.signal,
+        abortMessage: 'Protocol V2 BLE write aborted for Ping',
+        writePacket,
+      })
+    ).rejects.toThrow('Protocol V2 BLE write aborted for Ping');
+
+    expect(writePacket).toHaveBeenCalledTimes(1);
+  });
+
+  test('applies bounded burst pauses and one final flush delay', async () => {
+    const waits = [];
+    const writePacket = jest.fn().mockResolvedValue(undefined);
+
+    await writeProtocolV2BleFrame({
+      frame: new Uint8Array(10),
+      packetCapacity: 3,
+      initialDelayMs: 3,
+      burstSize: 2,
+      burstPauseMs: 7,
+      flushDelayMs: 11,
+      wait: ms => {
+        waits.push(ms);
+        return Promise.resolve();
+      },
+      writePacket,
+    });
+
+    expect(writePacket).toHaveBeenCalledTimes(4);
+    expect(waits).toEqual([3, 7, 11]);
+  });
+
+  test('rejects an invalid packet capacity before writing', async () => {
+    const writePacket = jest.fn();
+
+    await expect(
+      writeProtocolV2BleFrame({
+        frame: new Uint8Array(4),
+        packetCapacity: 0,
+        writePacket,
+      })
+    ).rejects.toThrow('Protocol V2 BLE packet capacity must be a positive integer');
+
+    expect(writePacket).not.toHaveBeenCalled();
+  });
+});

package/__tests__/protocol-v2-link-manager.test.js

@@ -26,6 +26,9 @@ const protocolV2Messages = parseConfigure({
         message: { type: 'string', id: 1 },
       },
     },
+    Cancel: {
+      fields: {},
+    },
     Success: {
       fields: {
         message: { type: 'string', id: 1 },
@@ -35,6 +38,7 @@ const protocolV2Messages = parseConfigure({
       values: {
         MessageType_Ping: 60206,
         MessageType_Success: 60207,
+        MessageType_Cancel: 60004,
       },
     },
   },
@@ -55,7 +59,12 @@ const rewriteSeq = (frame, seq) => {
 const createAdapterFactory = sentSeqs => {
   const adapters = [];
   let generation = 0;
-  const success = ProtocolV2.encodeFrame(schemas, 'Success', { message: 'ok' });
+  const success = ProtocolV2.encodeFrame(
+    schemas,
+    'Success',
+    { message: 'ok' },
+    { router: 1, packetSrc: 0, seq: 1 }
+  );
 
   return {
     adapters,
@@ -108,12 +117,15 @@ describe('ProtocolV2LinkManager', () => {
 
     await manager.call('device-a', createAdapter, 'Ping', { message: '1' }, { timeoutMs: 123 });
 
-    expect(adapters[0].prepareCall).toHaveBeenCalledWith({
-      messageName: 'Ping',
-      timeoutMs: 123,
-      highVolume: false,
-      generation: 1,
-    });
+    expect(adapters[0].prepareCall).toHaveBeenCalledWith(
+      expect.objectContaining({
+        messageName: 'Ping',
+        timeoutMs: 123,
+        highThroughput: false,
+        generation: 1,
+        signal: expect.any(AbortSignal),
+      })
+    );
   });
 
   test('invalidates a link-fatal call before the next call creates a new link', async () => {
@@ -178,6 +190,54 @@ describe('ProtocolV2LinkManager', () => {
     expect(adapters[1].reset).toHaveBeenCalledWith('schema changed');
   });
 
+  test('waits for an in-flight native cleanup before a concurrent invalidation resolves', async () => {
+    const sentSeqs = [];
+    const { adapters, createAdapter } = createAdapterFactory(sentSeqs);
+    let markCleanupStarted;
+    let finishCleanup;
+    const cleanupStarted = new Promise(resolve => {
+      markCleanupStarted = resolve;
+    });
+    const cleanupBlocked = new Promise(resolve => {
+      finishCleanup = resolve;
+    });
+    const onLinkInvalidated = jest.fn(async () => {
+      markCleanupStarted();
+      await cleanupBlocked;
+    });
+    const manager = new ProtocolV2LinkManager({
+      getSchemas: () => schemas,
+      classifyError: () => 'recoverable',
+      onLinkInvalidated,
+    });
+
+    await manager.call('device-a', createAdapter, 'Ping', { message: '1' });
+
+    const release = manager.invalidateLink('device-a', 'release');
+    await cleanupStarted;
+
+    let acquireSettled = false;
+    const acquire = manager.invalidateLink('device-a', 'acquire').then(() => {
+      acquireSettled = true;
+    });
+    await new Promise(resolve => {
+      setImmediate(resolve);
+    });
+
+    expect(acquireSettled).toBe(false);
+    expect(adapters[0].reset).toHaveBeenCalledTimes(1);
+    expect(onLinkInvalidated).toHaveBeenCalledTimes(1);
+
+    finishCleanup();
+    await Promise.all([release, acquire]);
+
+    await manager.call('device-a', createAdapter, 'Ping', { message: '2' });
+
+    expect(acquireSettled).toBe(true);
+    expect(sentSeqs).toEqual([1, 2]);
+    expect(adapters).toHaveLength(2);
+  });
+
   test('dispose clears active links and sequence cursors', async () => {
     const sentSeqs = [];
     const { adapters, createAdapter } = createAdapterFactory(sentSeqs);
@@ -200,7 +260,12 @@ describe('ProtocolV2LinkManager', () => {
     const deviceABlocked = new Promise(resolve => {
       releaseDeviceA = resolve;
     });
-    const success = ProtocolV2.encodeFrame(schemas, 'Success', { message: 'ok' });
+    const success = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: 1, packetSrc: 0, seq: 1 }
+    );
     const createAdapter = key => {
       let requestSeq = 0;
       return {
@@ -252,6 +317,128 @@ describe('ProtocolV2LinkManager', () => {
     ]);
   });
 
+  test('times out a queued call without sending it after the active call settles', async () => {
+    let releaseActiveRead;
+    let markActiveReadStarted;
+    const activeReadStarted = new Promise(resolve => {
+      markActiveReadStarted = resolve;
+    });
+    const activeReadBlocked = new Promise(resolve => {
+      releaseActiveRead = resolve;
+    });
+    const sentSeqs = [];
+    const success = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: 1, packetSrc: 0, seq: 1 }
+    );
+    let requestSeq = 0;
+    let readCount = 0;
+    const adapter = {
+      router: 1,
+      generation: 1,
+      prepareCall: jest.fn(),
+      writeFrame: jest.fn(frame => {
+        [, , , , , , requestSeq] = frame;
+        sentSeqs.push(requestSeq);
+        return Promise.resolve();
+      }),
+      readFrame: jest.fn(async () => {
+        readCount += 1;
+        if (readCount === 1) {
+          markActiveReadStarted();
+          await activeReadBlocked;
+        }
+        return rewriteSeq(success, requestSeq);
+      }),
+      reset: jest.fn(),
+      createTimeoutError: (name, timeoutMs) =>
+        new Error(`response timeout after ${timeoutMs}ms for ${name}`),
+    };
+    const manager = new ProtocolV2LinkManager({
+      getSchemas: () => schemas,
+      classifyError: () => 'recoverable',
+    });
+    const createAdapter = jest.fn(() => adapter);
+
+    const activeCall = manager.call('device-a', createAdapter, 'Ping', { message: 'active' });
+    await activeReadStarted;
+    const queuedCall = manager.call(
+      'device-a',
+      createAdapter,
+      'Ping',
+      { message: 'queued' },
+      { timeoutMs: 20 }
+    );
+
+    await expect(queuedCall).rejects.toThrow('response timeout after 20ms for Ping');
+    expect(sentSeqs).toEqual([1]);
+
+    releaseActiveRead();
+    await activeCall;
+    await expect(
+      manager.call('device-a', createAdapter, 'Ping', { message: 'after-timeout' })
+    ).resolves.toEqual({
+      type: 'Success',
+      message: { message: 'ok' },
+    });
+
+    expect(sentSeqs).toEqual([1, 2]);
+  });
+
+  test('writes flow control while the active call is waiting for its response', async () => {
+    const sentSeqs = [];
+    let releaseRead;
+    let markReadStarted;
+    const readStarted = new Promise(resolve => {
+      markReadStarted = resolve;
+    });
+    const readBlocked = new Promise(resolve => {
+      releaseRead = resolve;
+    });
+    const success = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: 1, packetSrc: 0, seq: 1 }
+    );
+    let requestSeq = 0;
+    const adapter = {
+      router: 1,
+      generation: 1,
+      prepareCall: jest.fn(),
+      writeFrame: jest.fn(frame => {
+        [, , , , , , requestSeq] = frame;
+        sentSeqs.push(requestSeq);
+        return Promise.resolve();
+      }),
+      readFrame: jest.fn(async () => {
+        markReadStarted();
+        await readBlocked;
+        return rewriteSeq(success, 1);
+      }),
+      reset: jest.fn(),
+    };
+    const manager = new ProtocolV2LinkManager({
+      getSchemas: () => schemas,
+      classifyError: () => 'recoverable',
+    });
+    const createAdapter = jest.fn(() => adapter);
+
+    const activeCall = manager.call('device-a', createAdapter, 'Ping', { message: 'pending' });
+    await readStarted;
+    await expect(manager.sendFlowControl('device-a', createAdapter, 'Cancel', {})).resolves.toEqual(
+      { type: 'WriteCompleted', message: {} }
+    );
+
+    expect(sentSeqs).toEqual([1, 2]);
+    expect(adapter.prepareCall).toHaveBeenCalledTimes(1);
+    expect(adapter.readFrame).toHaveBeenCalledTimes(1);
+    releaseRead();
+    await activeCall;
+  });
+
   test('keeps a recoverable link after a call error', async () => {
     const sentSeqs = [];
     const { adapters, createAdapter } = createAdapterFactory(sentSeqs);
@@ -298,7 +485,12 @@ describe('ProtocolV2LinkManager', () => {
     const writeBlocked = new Promise(resolve => {
       releaseWrite = resolve;
     });
-    const success = ProtocolV2.encodeFrame(schemas, 'Success', { message: 'ok' });
+    const success = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: 1, packetSrc: 0, seq: 1 }
+    );
     const adapter = {
       router: 1,
       generation: 1,
@@ -323,4 +515,49 @@ describe('ProtocolV2LinkManager', () => {
     await expect(call).rejects.toThrow('device disconnected');
     expect(adapter.readFrame).not.toHaveBeenCalled();
   });
+
+  test('rejects calls queued before their link generation is invalidated', async () => {
+    let releaseWrite;
+    let markWriteStarted;
+    const writeStarted = new Promise(resolve => {
+      markWriteStarted = resolve;
+    });
+    const writeBlocked = new Promise(resolve => {
+      releaseWrite = resolve;
+    });
+    const success = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: 1, packetSrc: 0, seq: 1 }
+    );
+    const adapter = {
+      router: 1,
+      generation: 1,
+      prepareCall: jest.fn(),
+      writeFrame: jest.fn(async () => {
+        markWriteStarted();
+        await writeBlocked;
+      }),
+      readFrame: jest.fn(() => Promise.resolve(success)),
+      reset: jest.fn(),
+    };
+    const createAdapter = jest.fn(() => adapter);
+    const manager = new ProtocolV2LinkManager({
+      getSchemas: () => schemas,
+      classifyError: () => 'recoverable',
+    });
+
+    const activeCall = manager.call('device-a', createAdapter, 'Ping', { message: 'active' });
+    await writeStarted;
+    const queuedCall = manager.call('device-a', createAdapter, 'Ping', { message: 'queued' });
+    await manager.invalidateLink('device-a', 'device released');
+    releaseWrite();
+
+    await expect(activeCall).rejects.toThrow('device released');
+    await expect(queuedCall).rejects.toThrow('device released');
+    expect(createAdapter).toHaveBeenCalledTimes(1);
+    expect(adapter.writeFrame).toHaveBeenCalledTimes(1);
+    expect(adapter.readFrame).not.toHaveBeenCalled();
+  });
 });