feat(transport): allow custom chunkSize in protocol-v1.encode

packages/protocol/src/protocol-v1/encode.ts

@@ -11,6 +11,7 @@ import { TransportProtocolEncode } from '../types';
 export const encode: TransportProtocolEncode = (data, options) => {
     const { messageType } = options;
     const fullSize = HEADER_SIZE + data.limit;
+    const chunkSize = options.chunkSize || BUFFER_SIZE;
 
     const encodedByteBuffer = new ByteBuffer(fullSize);
 
@@ -29,7 +30,7 @@ export const encode: TransportProtocolEncode = (data, options) => {
 
     encodedByteBuffer.reset();
 
-    const size = BUFFER_SIZE - 1;
+    const size = chunkSize - 1;
 
     const chunkCount = Math.ceil(encodedByteBuffer.limit / size) || 1;
 
@@ -42,7 +43,7 @@ export const encode: TransportProtocolEncode = (data, options) => {
         const start = i * size;
         const end = Math.min((i + 1) * size, encodedByteBuffer.limit);
 
-        const buffer = new ByteBuffer(BUFFER_SIZE);
+        const buffer = new ByteBuffer(chunkSize);
 
         buffer.writeByte(MESSAGE_MAGIC_HEADER_BYTE);
 

packages/protocol/src/types.ts

@@ -6,6 +6,7 @@ export type TransportProtocolDecode = (bytes: ArrayBuffer) => {
 
 export interface TransportProtocolEncodeOptions {
     messageType: number;
+    chunkSize?: number;
 }
 
 export type TransportProtocolEncode = (

packages/transport/tests/abstractUsb.test.ts

@@ -351,6 +351,49 @@ describe('Usb', () => {
             });
         });
 
+        it('send protocol-v1 with custom chunkSize', async () => {
+            await transport.enumerate().promise;
+            const acquireRes = await transport.acquire({ input: { path: '123', previous: null } })
+                .promise;
+            expect(acquireRes.success).toEqual(true);
+            if (!acquireRes.success) return;
+
+            const writeSpy = jest
+                .spyOn(testUsbApi, 'write')
+                .mockImplementation(() => Promise.resolve({ success: true, payload: undefined }));
+
+            // override protocol options
+            const overrideProtocol = (protocol: typeof v1Protocol, chunkSize: number) =>
+                ({
+                    ...protocol,
+                    encode: (...[data, options]: Parameters<typeof protocol.encode>) =>
+                        protocol.encode(data, { ...options, chunkSize }),
+                }) as typeof protocol;
+
+            const send = (chunkSize: number) =>
+                transport.send({
+                    name: 'SignMessage',
+                    data: {
+                        message: '00'.repeat(200),
+                    },
+                    session: acquireRes.payload,
+                    protocol: overrideProtocol(v1Protocol, chunkSize),
+                }).promise;
+
+            // count encoded/sent chunks
+            await send(64); // default usb
+            expect(writeSpy).toBeCalledTimes(4);
+            writeSpy.mockClear();
+
+            await send(16); // smaller chunks
+            expect(writeSpy).toBeCalledTimes(15);
+            writeSpy.mockClear();
+
+            await send(128); // bigger chunks
+            expect(writeSpy).toBeCalledTimes(2);
+            writeSpy.mockClear();
+        });
+
         it('release', async () => {
             await transport.enumerate().promise;
             const acquireRes = await transport.acquire({ input: { path: '123', previous: null } })