transport branded types and fix release device

packages/connect/src/device/Device.ts

@@ -323,7 +323,9 @@ export class Device extends TypedEmitter<DeviceEvents> {
         // session was acquired by another instance. but another might not have power to release interface
         // so it only notified about its session acquiral and the interrupted instance should cooperate
         // and release device too.
-        this.transport.releaseDevice(this.originalDescriptor.path);
+        if (this.originalDescriptor.session) {
+            this.transport.releaseDevice(this.originalDescriptor.session);
+        }
     }
 
     async _runInner<X>(fn: (() => Promise<X>) | undefined, options: RunOptions): Promise<void> {

packages/transport/src/api/abstract.ts

@@ -5,6 +5,7 @@ import type {
     Success,
     Logger,
     DescriptorApiLevel,
+    PathInternal,
 } from '../types';
 import { success, error, unknownError } from '../utils/result';
 
@@ -68,7 +69,7 @@ export abstract class AbstractApi extends TypedEmitter<{
      * read from device on path
      */
     abstract read(
-        path: string,
+        path: PathInternal,
         signal?: AbortSignal,
     ): AsyncResultWithTypedError<
         Buffer,
@@ -85,7 +86,7 @@ export abstract class AbstractApi extends TypedEmitter<{
      * write to device on path
      */
     abstract write(
-        path: string,
+        path: PathInternal,
         buffers: Buffer,
         signal?: AbortSignal,
     ): AsyncResultWithTypedError<
@@ -102,7 +103,7 @@ export abstract class AbstractApi extends TypedEmitter<{
      * set device to the state when it is available to read/write
      */
     abstract openDevice(
-        path: string,
+        path: PathInternal,
         first: boolean,
         signal?: AbortSignal,
     ): AsyncResultWithTypedError<
@@ -118,7 +119,7 @@ export abstract class AbstractApi extends TypedEmitter<{
      * set device to the state when it is available to openDevice again
      */
     abstract closeDevice(
-        path: string,
+        path: PathInternal,
     ): AsyncResultWithTypedError<
         undefined,
         | typeof ERRORS.DEVICE_NOT_FOUND

packages/transport/src/api/udp.ts

@@ -7,7 +7,7 @@ import {
     AbstractApiConstructorParams,
     DEVICE_TYPE,
 } from './abstract';
-import { DescriptorApiLevel } from '../types';
+import { DescriptorApiLevel, PathInternal } from '../types';
 import * as ERRORS from '../errors';
 
 export class UdpApi extends AbstractApi {
@@ -161,7 +161,9 @@ export class UdpApi extends AbstractApi {
 
     public async enumerate(signal?: AbortSignal) {
         // in theory we could support multiple devices, but we don't yet
-        const paths = this.debugLink ? ['127.0.0.1:21325'] : ['127.0.0.1:21324'];
+        const paths = this.debugLink
+            ? [PathInternal('127.0.0.1:21325')]
+            : [PathInternal('127.0.0.1:21324')];
 
         try {
             const enumerateResult = await Promise.all(

packages/transport/src/api/usb.ts

@@ -1,7 +1,7 @@
 import { createDeferred, createTimeoutPromise } from '@trezor/utils';
 
 import { AbstractApi, AbstractApiConstructorParams, DEVICE_TYPE } from './abstract';
-import { DescriptorApiLevel } from '../types';
+import { DescriptorApiLevel, PathInternal } from '../types';
 import {
     CONFIGURATION_ID,
     ENDPOINT_ID,
@@ -121,7 +121,7 @@ export class UsbApi extends AbstractApi {
 
     private devicesToDescriptors(): DescriptorApiLevel[] {
         return this.devices.map(d => ({
-            path: d.path,
+            path: PathInternal(d.path),
             type: this.matchDeviceType(d.device),
             product: d.device.productId,
             vendor: d.device.vendorId,

packages/transport/src/sessions/background.ts

@@ -22,10 +22,14 @@ import type {
     HandleMessageParams,
     HandleMessageResponse,
 } from './types';
-import type { Descriptor, PathInternal, PathPublic, Success } from '../types';
-
+import type { Descriptor, PathInternal, Success } from '../types';
+import { PathPublic, Session } from '../types';
 import * as ERRORS from '../errors';
 
+function typedObjectKeys<T extends Record<any, any>>(obj: T): Array<keyof T> {
+    return Object.keys(obj) as Array<keyof T>;
+}
+
 type DescriptorsDict = Record<PathInternal, Descriptor>;
 
 // in nodeusb, enumeration operation takes ~3 seconds
@@ -123,7 +127,7 @@ export class SessionsBackground extends TypedEmitter<{
      * - caller informs about current descriptors
      */
     private enumerateDone(payload: EnumerateDoneRequest) {
-        const disconnectedDevices = Object.keys(this.descriptors).filter(
+        const disconnectedDevices = typedObjectKeys(this.descriptors).filter(
             pathInternal => !payload.descriptors.find(d => d.path === pathInternal),
         );
 
@@ -134,7 +138,7 @@ export class SessionsBackground extends TypedEmitter<{
 
         payload.descriptors.forEach(d => {
             if (!this.pathInternalPathPublicMap[d.path]) {
-                this.pathInternalPathPublicMap[d.path] = `${(this.lastPathId += 1)}`;
+                this.pathInternalPathPublicMap[d.path] = PathPublic(`${(this.lastPathId += 1)}`);
             }
             if (!this.descriptors[d.path]) {
                 this.descriptors[d.path] = {
@@ -186,7 +190,7 @@ export class SessionsBackground extends TypedEmitter<{
         const unconfirmedSessions: DescriptorsDict = JSON.parse(JSON.stringify(this.descriptors));
 
         this.lastSessionId++;
-        unconfirmedSessions[pathInternal].session = `${this.lastSessionId}`;
+        unconfirmedSessions[pathInternal].session = Session(`${this.lastSessionId}`);
 
         return this.success({
             session: unconfirmedSessions[pathInternal].session,
@@ -206,7 +210,7 @@ export class SessionsBackground extends TypedEmitter<{
         if (!pathInternal || !this.descriptors[pathInternal]) {
             return this.error(ERRORS.DESCRIPTOR_NOT_FOUND);
         }
-        this.descriptors[pathInternal].session = `${this.lastSessionId}`;
+        this.descriptors[pathInternal].session = Session(`${this.lastSessionId}`);
 
         return Promise.resolve(
             this.success({
@@ -241,7 +245,7 @@ export class SessionsBackground extends TypedEmitter<{
     }
 
     private getPathBySession({ session }: GetPathBySessionRequest) {
-        const path = Object.keys(this.descriptors).find(
+        const path = typedObjectKeys(this.descriptors).find(
             pathKey => this.descriptors[pathKey]?.session === session,
         );
 
@@ -309,7 +313,7 @@ export class SessionsBackground extends TypedEmitter<{
     }
 
     private getInternal(pathPublic: PathPublic): PathInternal | undefined {
-        return Object.keys(this.pathInternalPathPublicMap).find(
+        return typedObjectKeys(this.pathInternalPathPublicMap).find(
             internal => this.pathInternalPathPublicMap[internal] === pathPublic,
         );
     }

packages/transport/src/transports/abstract.ts

@@ -266,7 +266,7 @@ export abstract class AbstractTransport extends TransportEmitter {
      * For transports with native access (webusb), this informs lower transport layer
      * that device is not going to be used anymore
      */
-    abstract releaseDevice(path: string): AsyncResultWithTypedError<void, string>;
+    abstract releaseDevice(session: Session): AsyncResultWithTypedError<void, string>;
 
     /**
      * Encode data and write it to transport layer

packages/transport/src/transports/abstractApi.ts

@@ -11,6 +11,7 @@
 import { receiveAndParse } from '../utils/receive';
 import { SessionsClient } from '../sessions/client';
 import * as ERRORS from '../errors';
+import { Session } from '../types';
 
 interface ConstructorParams extends AbstractTransportParams {
     api: AbstractApi;
@@ -156,7 +157,7 @@
                     return this.error({ error: releaseIntentResponse.error });
                 }
 
-                const releasePromise = this.releaseDevice(releaseIntentResponse.payload.path);
+                const releasePromise = this.releaseDevice(session);
                 if (onClose) return this.success(undefined);
 
                 await releasePromise;
@@ -315,8 +316,17 @@
         );
     }
 
-    releaseDevice(path: string) {
-        return this.api.closeDevice(path);
+    releaseDevice(session: Session) {
+        return this.sessionsClient
+            .getPathBySession({
+                session,
+            })
+            .then(response => {
+                if (response.success) {
+                    return this.api.closeDevice(response.payload.path);
+                }
+                return this.success(undefined);
+            });
     }
 
     stop() {

packages/transport/src/types/index.ts

@@ -2,10 +2,18 @@ import type { DEVICE_TYPE } from '../api/abstract';
 
 export * from './apiCall';
 
-export type Session = `${number}`;
-
-export type PathInternal = string;
-export type PathPublic = `${number}`;
+export type Session = `${number}` & { __type: 'Session' };
+export const Session = (input: `${number}`) => {
+    return `${input}` as Session;
+};
+export type PathInternal = string & { __type: 'PathInternal' };
+export const PathInternal = (input: string) => {
+    return input as PathInternal;
+};
+export type PathPublic = `${number}` & { __type: 'PathPublic' };
+export const PathPublic = (input: `${number}`) => {
+    return `${input}` as PathPublic;
+};
 
 export type DescriptorApiLevel = {
     path: PathInternal;

packages/transport/tests/abstractUsb.test.ts

@@ -5,6 +5,7 @@ import { UsbApi } from '../src/api/usb';
 import { SessionsClient } from '../src/sessions/client';
 import { SessionsBackground } from '../src/sessions/background';
 import * as messages from '@trezor/protobuf/messages.json';
+import { PathPublic, Session } from '../src/types';
 
 // create devices otherwise returned from navigator.usb.getDevices
 const createMockedDevice = (optional = {}) => ({
@@ -183,7 +184,7 @@ describe('Usb', () => {
             const spy = jest.fn();
             transport.on('transport-update', spy);
 
-            transport.handleDescriptorsChange([{ path: '1', session: null, type: 1 }]);
+            transport.handleDescriptorsChange([{ path: PathPublic('1'), session: null, type: 1 }]);
 
             expect(spy).toHaveBeenCalledWith([
                 { type: 'connected', descriptor: { path: '1', session: null, type: 1 } },
@@ -230,7 +231,9 @@ describe('Usb', () => {
 
             jest.runAllTimers();
 
-            const result = await transport.acquire({ input: { path: '1', previous: null } });
+            const result = await transport.acquire({
+                input: { path: PathPublic('1'), previous: null },
+            });
             expect(result).toEqual({
                 success: true,
                 payload: '1',
@@ -254,10 +257,14 @@ describe('Usb', () => {
             transport.listen();
 
             // set some initial descriptors
-            const acquireCall = transport.acquire({ input: { path: '1', previous: null } });
+            const acquireCall = transport.acquire({
+                input: { path: PathPublic('1'), previous: null },
+            });
 
             setTimeout(() => {
-                sessionsClient.emit('descriptors', [{ path: '321', session: '1', type: 1 }]);
+                sessionsClient.emit('descriptors', [
+                    { path: PathPublic('321'), session: Session('1'), type: 1 },
+                ]);
             }, 1);
 
             const res = await acquireCall;
@@ -280,10 +287,12 @@ describe('Usb', () => {
             transport.listen();
 
             // set some initial descriptors
-            const acquireCall = transport.acquire({ input: { path: '1', previous: null } });
+            const acquireCall = transport.acquire({
+                input: { path: PathPublic('1'), previous: null },
+            });
             setTimeout(() => {
                 sessionsClient.emit('descriptors', [
-                    { path: '1', session: '2', type: 1, product: 21441 },
+                    { path: PathPublic('1'), session: Session('2'), type: 1, product: 21441 },
                 ]);
             }, 1);
 
@@ -297,7 +306,7 @@ describe('Usb', () => {
             const res = await transport.call({
                 name: 'GetAddress',
                 data: {},
-                session: '1',
+                session: Session('1'),
                 protocol: v1Protocol,
             });
             expect(res).toEqual({ success: false, error: 'device disconnected during action' });
@@ -307,7 +316,9 @@ describe('Usb', () => {
         it('call - with valid and invalid message.', async () => {
             const { transport, sessionsBackground } = await initTest();
             await transport.enumerate();
-            const acquireRes = await transport.acquire({ input: { path: '1', previous: null } });
+            const acquireRes = await transport.acquire({
+                input: { path: PathPublic('1'), previous: null },
+            });
             expect(acquireRes.success).toEqual(true);
             if (!acquireRes.success) return;
 
@@ -350,7 +361,9 @@ describe('Usb', () => {
         it('send and receive.', async () => {
             const { transport, sessionsBackground } = await initTest();
             await transport.enumerate();
-            const acquireRes = await transport.acquire({ input: { path: '1', previous: null } });
+            const acquireRes = await transport.acquire({
+                input: { path: PathPublic('1'), previous: null },
+            });
             expect(acquireRes.success).toEqual(true);
             if (!acquireRes.success) return;
 
@@ -386,7 +399,9 @@ describe('Usb', () => {
         it('send protocol-v1 with custom chunkSize', async () => {
             const { transport, testUsbApi, sessionsBackground } = await initTest();
             await transport.enumerate();
-            const acquireRes = await transport.acquire({ input: { path: '1', previous: null } });
+            const acquireRes = await transport.acquire({
+                input: { path: PathPublic('1'), previous: null },
+            });
             expect(acquireRes.success).toEqual(true);
             if (!acquireRes.success) return;
 
@@ -424,7 +439,9 @@ describe('Usb', () => {
         it('release', async () => {
             const { transport, sessionsBackground } = await initTest();
             await transport.enumerate();
-            const acquireRes = await transport.acquire({ input: { path: '1', previous: null } });
+            const acquireRes = await transport.acquire({
+                input: { path: PathPublic('1'), previous: null },
+            });
             expect(acquireRes.success).toEqual(true);
             if (!acquireRes.success) return;
 
@@ -433,7 +450,7 @@ describe('Usb', () => {
             // doesn't really matter what what message we send
             const res = await transport.release({
                 session: acquireRes.payload,
-                path: '123',
+                path: PathPublic('123'),
                 onClose: false,
             });
             expect(res).toEqual({
@@ -446,7 +463,9 @@ describe('Usb', () => {
         it('call - with use abort', async () => {
             const { transport, sessionsBackground } = await initTest();
             await transport.enumerate();
-            const acquireRes = await transport.acquire({ input: { path: '1', previous: null } });
+            const acquireRes = await transport.acquire({
+                input: { path: PathPublic('1'), previous: null },
+            });
             if (!acquireRes.success) return;
 
             const abort = new AbortController();